@stravica-ai/digital-operator-pa 0.1.1 → 0.1.2

package/dist/engineering-pa-workspace/src/nav.mjs

@@ -12,9 +12,26 @@
  *   - A missing or absent operator manifest is not an error.
  *   - A malformed manifest is logged and skipped; the other side still loads.
  *
- * Caching: each load checks both manifest mtimes. The cached merged list is
- * returned unchanged if neither file changed since the last load. Missing
- * files are tracked with mtime 0 so their appearance triggers a reload.
+ * Per-device scoping: after merging, entries whose target page is not
+ * materialised on THIS device are dropped (not just warned). The estate runs
+ * one shared nav manifest that lists every page across all library repos, but
+ * `library-sync` only writes a page file onto a device when the repo that owns
+ * it is mounted there. So the presence of the href's target page file IS the
+ * per-entry materialisation signal — an hq-only page (e.g. article-ideas,
+ * content-calendar, both under operator/extensions/workspace/) is absent on a
+ * device that doesn't mount stravica-library-hq, so its nav entry is hidden
+ * rather than rendered as a dangling 404 link. This needs no per-entry "owner"
+ * field and no coupling to the .library-sync manifest internals: the page file
+ * library-sync lays down (or omits) is the source of truth. Hrefs whose shape
+ * we can't resolve to a local page (external links, deep paths) are left
+ * untouched.
+ *
+ * Caching: each load checks both manifest mtimes. The cached (merged + scoped)
+ * list is returned unchanged if neither file changed since the last load.
+ * Missing files are tracked with mtime 0 so their appearance triggers a reload.
+ * `library-sync` rewrites the extension nav.json as part of the same mount tree
+ * whenever it materialises or removes pages, so a materialisation transition
+ * always bumps a manifest mtime and re-triggers scoping.
  */
 
 import { readFileSync, statSync, existsSync } from 'node:fs';
@@ -107,35 +124,50 @@ function mergeItems(coreItems, extItems, warn) {
 }
 
 /**
- * Validate that every item's href resolves to an existing page, either under
- * APP_DIR or EXT_DIR (for top-level /<name>.html). Non-resolving items are
- * kept in the list with a warning so operators can see their work-in-progress.
+ * Classify an href by whether its target page is materialised on this device.
+ * Returns 'present', 'absent', or 'unresolvable'.
+ *
+ *   - Core-shape paths (/core/tools/workspace/app/<file>) resolve under appDir.
+ *   - Top-level extension-shape paths (/<file>.html) resolve under extDir or appDir.
+ *   - Any other shape (external links, deep paths) is 'unresolvable' — we cannot
+ *     (and should not) judge its local presence, so callers leave it untouched.
  */
-function warnOnMissingHrefs(items, appDir, extDir, warn) {
+function pagePresence(href, appDir, extDir) {
+  const corePrefix = '/core/tools/workspace/app/';
+  if (href.indexOf(corePrefix) === 0) {
+    const name = href.slice(corePrefix.length).split('?')[0].split('#')[0];
+    if (!name) return 'unresolvable';
+    return existsSync(join(appDir, name)) ? 'present' : 'absent';
+  }
+  const topMatch = href.match(/^\/([^/?#]+\.html)(?:[?#].*)?$/);
+  if (topMatch) {
+    const name = topMatch[1];
+    const inExt = extDir && existsSync(join(extDir, name));
+    const inApp = existsSync(join(appDir, name));
+    return (inExt || inApp) ? 'present' : 'absent';
+  }
+  return 'unresolvable';
+}
+
+/**
+ * Scope the merged list to this device: drop any entry whose target page is
+ * resolvable-in-shape but absent from disk (i.e. its owning library repo is not
+ * materialised here), logging why. Entries whose page is present, or whose href
+ * shape we can't resolve to a local page, are kept. This is what makes a shared
+ * estate-wide nav manifest render cleanly per-device without hand-editing:
+ * hq-only entries vanish on non-HQ devices because their pages were never
+ * written there.
+ */
+function scopeToMaterialised(items, appDir, extDir, warn) {
+  const kept = [];
   for (const item of items) {
-    const href = item.href;
-    // Core-shape paths: /core/tools/workspace/app/<file>
-    const corePrefix = '/core/tools/workspace/app/';
-    if (href.indexOf(corePrefix) === 0) {
-      const name = href.slice(corePrefix.length).split('?')[0].split('#')[0];
-      if (!existsSync(join(appDir, name))) {
-        warn('[nav] warning: nav item "' + item.id + '" points at missing page ' + href);
-      }
+    if (pagePresence(item.href, appDir, extDir) === 'absent') {
+      warn('[nav] hidden: nav item "' + item.id + '" page not materialised on this device (' + item.href + ')');
       continue;
     }
-    // Top-level extension-shape: /<file>.html
-    const topMatch = href.match(/^\/([^/?#]+\.html)(?:[?#].*)?$/);
-    if (topMatch) {
-      const name = topMatch[1];
-      const inExt = extDir && existsSync(join(extDir, name));
-      const inApp = existsSync(join(appDir, name));
-      if (!inExt && !inApp) {
-        warn('[nav] warning: nav item "' + item.id + '" points at missing page ' + href);
-      }
-      continue;
-    }
-    // Any other shape we leave alone — might be an external link or a deep core path.
+    kept.push(item);
   }
+  return kept;
 }
 
 /**
@@ -172,12 +204,12 @@ export function loadNav(opts) {
     ? readManifest(extManifest, 'extension nav manifest', warn)
     : [];
   const merged = mergeItems(coreItems, extItems, warn);
-  warnOnMissingHrefs(merged, appDir, extDir, warn);
+  const scoped = scopeToMaterialised(merged, appDir, extDir, warn);
 
   CACHE.coreMtimeMs = coreMtime;
   CACHE.extMtimeMs = extMtime;
-  CACHE.items = merged;
-  return merged;
+  CACHE.items = scoped;
+  return scoped;
 }
 
 /**

package/dist/engineering-pa-workspace/src/server.mjs

@@ -60,6 +60,11 @@ const APP_DIR = resolve(__dirname, '..', 'app');
 const DEBUG = process.env.WS_DEBUG === '1';
 const log = DEBUG ? console.log.bind(console) : function () {};
 const warn = DEBUG ? console.warn.bind(console) : function () {};
+// Always-on warning sink. Most diagnostics stay silent unless WS_DEBUG=1, but
+// failures that silently break operator-visible surface area (e.g. a whole
+// extension failing to load, presenting as a vague UI outage) must ALWAYS be
+// visible so the root cause is diagnosable without re-running under WS_DEBUG.
+const warnAlways = console.warn.bind(console);
 
 // --- Extension dir ---
 // Convention: operator/extensions/workspace/ overlays core app pages and
@@ -461,7 +466,11 @@ async function loadExtensions() {
       });
     }
   } catch (e) {
-    warn('[workspace] Extension api.mjs failed to load: ' + e.message);
+    // Always warn — a failed extension import takes out every route the
+    // extension registers, which surfaces to the operator as a broken UI with
+    // no obvious cause. Name the extension and the error; keep the server
+    // alive (a bad extension must not take down the whole workspace).
+    warnAlways('[workspace] Extension failed to load: ' + extApiPath + ' — ' + (e && e.stack ? e.stack : e));
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stravica-ai/digital-operator-pa",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Digital Operator PA — single-bundled public package surface (bins + library) for the platform.",
   "type": "module",
   "main": "./index.mjs",