@rubytech/create-realagent 1.0.853 → 1.0.855

package/payload/platform/scripts/component-knowledgedoc-backfill.ts

@@ -0,0 +1,214 @@
+#!/usr/bin/env -S node --loader tsx
+/**
+ * Task 942 — backfill :KnowledgeDocument projections for legacy
+ * :Component rows whose render-component was emitted before this
+ * task landed.
+ *
+ * Walks every `:Component {name ∈ PERSISTENT_COMPONENTS}` row that
+ * lacks a sibling `:KnowledgeDocument` (matched by accountId +
+ * deterministic attachmentId derived from the component's id) and
+ * for each one materialises the file on disk + MERGEs the projection
+ * row in a single Cypher tx. Idempotent — re-running against the
+ * same rows is a no-op (MERGE collapses, file write rewrites the
+ * same bytes).
+ *
+ * Usage:
+ *   tsx platform/scripts/component-knowledgedoc-backfill.ts \
+ *       [--account-id=<uuid>]                # optional filter, default = all accounts
+ *       [--dry-run]                          # print what would happen, do not write
+ *
+ * Exit codes:
+ *   0 = no rows needed backfill, OR all rows succeeded (including --dry-run)
+ *   1 = at least one row failed (disk write threw, Cypher tx threw)
+ *   2 = invocation / Neo4j connection error
+ *
+ * Per-row log line:
+ *   [component-kd-backfill] convId=<…> componentId=<…> outcome=created|skipped|failed reason=<…>
+ *
+ * The skip cases:
+ *  - component data does not contain `data.content` or `data.html`,
+ *  - both fields empty,
+ *  - the projection row already exists (idempotent re-run).
+ */
+
+import process from "node:process";
+
+import { isPersistentComponent, PERSISTENT_COMPONENTS } from "../lib/persistent-components/src/index";
+import { deriveComponentAttachmentId, deriveComponentTitle, pickComponentBytes } from "../ui/app/lib/claude-agent/component-attachment";
+import { getSession } from "../ui/app/lib/neo4j-store";
+import { storeComponentArtefact } from "../ui/app/lib/attachments";
+
+interface Args {
+  accountIdFilter?: string;
+  dryRun: boolean;
+}
+
+function parseArgs(argv: string[]): Args {
+  const out: Args = { dryRun: false };
+  for (const a of argv) {
+    const m = a.match(/^--([a-z-]+)(?:=(.+))?$/);
+    if (!m) continue;
+    const [, key, val] = m;
+    if (key === "account-id") out.accountIdFilter = val;
+    else if (key === "dry-run") out.dryRun = true;
+  }
+  return out;
+}
+
+interface ComponentRow {
+  componentId: string;
+  conversationId: string;
+  accountId: string;
+  name: string;
+  data: string;
+  existingAttachmentId: string | null;
+  messageId: string;
+}
+
+async function main(): Promise<number> {
+  const args = parseArgs(process.argv.slice(2));
+  const session = getSession();
+  let backfilled = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  try {
+    // Pull every PERSISTENT_COMPONENTS :Component row, optionally
+    // filtered by accountId. The query also returns the existing
+    // c.attachmentId (null on legacy / pre-942 rows). For legacy rows
+    // we derive attachmentId from componentId — it's the only stable
+    // identifier on the historical data — write the file, MERGE the
+    // projection, AND back-fill c.attachmentId so the audit harness
+    // collapses on the same row on its next run.
+    const componentNames = Array.from(PERSISTENT_COMPONENTS);
+    const filterClause = args.accountIdFilter ? "AND c.accountId = $accountId" : "";
+    const result = await session.run(
+      `MATCH (m:Message)-[:HAS_COMPONENT]->(c:Component)
+       WHERE c.name IN $names ${filterClause}
+       RETURN c.componentId AS componentId,
+              c.conversationId AS conversationId,
+              c.accountId AS accountId,
+              c.name AS name,
+              c.data AS data,
+              c.attachmentId AS existingAttachmentId,
+              m.messageId AS messageId
+       ORDER BY c.createdAt`,
+      args.accountIdFilter
+        ? { names: componentNames, accountId: args.accountIdFilter }
+        : { names: componentNames },
+    );
+
+    for (const record of result.records) {
+      const row: ComponentRow = {
+        componentId: record.get("componentId") as string,
+        conversationId: record.get("conversationId") as string,
+        accountId: record.get("accountId") as string,
+        name: record.get("name") as string,
+        data: record.get("data") as string,
+        existingAttachmentId: (record.get("existingAttachmentId") as string | null) ?? null,
+        messageId: record.get("messageId") as string,
+      };
+
+      if (!isPersistentComponent(row.name)) {
+        // Defensive — the WHERE clause already filters, but a future
+        // schema change might mismatch; log and move on.
+        skipped += 1;
+        console.log(`[component-kd-backfill] convId=${row.conversationId.slice(0, 8)} componentId=${row.componentId.slice(0, 8)} outcome=skipped reason=name-not-persistent`);
+        continue;
+      }
+
+      let dataObj: Record<string, unknown>;
+      try {
+        dataObj = JSON.parse(row.data) as Record<string, unknown>;
+      } catch {
+        skipped += 1;
+        console.log(`[component-kd-backfill] convId=${row.conversationId.slice(0, 8)} componentId=${row.componentId.slice(0, 8)} outcome=skipped reason=data-not-json`);
+        continue;
+      }
+
+      const bytesPick = pickComponentBytes(dataObj);
+      if (!bytesPick) {
+        skipped += 1;
+        console.log(`[component-kd-backfill] convId=${row.conversationId.slice(0, 8)} componentId=${row.componentId.slice(0, 8)} outcome=skipped reason=no-content-or-html`);
+        continue;
+      }
+
+      // Prefer the live-writer-stamped attachmentId when present;
+      // otherwise derive from componentId (legacy / pre-942 rows).
+      // The derived value is then written back onto :Component below
+      // so the audit harness sees a single source of truth on the
+      // next run.
+      const attachmentId = row.existingAttachmentId ?? deriveComponentAttachmentId(row.componentId);
+      const derivedFromComponentId = !row.existingAttachmentId;
+      const title = deriveComponentTitle(row.name, dataObj);
+      const filename = bytesPick.mimeType === "text/html" ? `${title}.html` : `${title}.md`;
+
+      if (args.dryRun) {
+        console.log(`[component-kd-backfill] convId=${row.conversationId.slice(0, 8)} componentId=${row.componentId.slice(0, 8)} outcome=dry-run attachmentId=${attachmentId.slice(0, 8)} mimeType=${bytesPick.mimeType} bytes=${bytesPick.content.length} source=${derivedFromComponentId ? "derived" : "stamped"}`);
+        continue;
+      }
+
+      try {
+        await storeComponentArtefact(row.accountId, attachmentId, bytesPick.mimeType, bytesPick.content, filename);
+      } catch (err) {
+        failed += 1;
+        const reason = err instanceof Error ? err.message : String(err);
+        console.log(`[component-kd-backfill] convId=${row.conversationId.slice(0, 8)} componentId=${row.componentId.slice(0, 8)} outcome=failed reason=disk-write:${JSON.stringify(reason.slice(0, 200))}`);
+        continue;
+      }
+
+      try {
+        // MERGE the projection + the discovery edge from :Message + back-fill
+        // c.attachmentId so the audit harness sees a single attachmentId
+        // source on its next run. The Cypher returns whether the projection
+        // was newly created or already existed, so the per-row log line
+        // distinguishes the two outcomes for forensic purposes.
+        const mergeResult = await session.run(
+          `MATCH (m:Message {messageId: $messageId, accountId: $accountId})
+           MATCH (m)-[:HAS_COMPONENT]->(c:Component {componentId: $componentId})
+           MERGE (k:KnowledgeDocument {accountId: $accountId, attachmentId: $attachmentId})
+           ON CREATE SET k.name = $title,
+                         k.encodingFormat = $mimeType,
+                         k.createdAt = datetime(),
+                         k.updatedAt = datetime()
+           ON MATCH SET k.updatedAt = datetime()
+           MERGE (m)-[:HAS_KNOWLEDGE_DOCUMENT]->(k)
+           SET c.attachmentId = $attachmentId
+           RETURN CASE WHEN k.createdAt = k.updatedAt THEN 'created' ELSE 'projection-existed' END AS state`,
+          {
+            accountId: row.accountId,
+            attachmentId,
+            title,
+            mimeType: bytesPick.mimeType,
+            messageId: row.messageId,
+            componentId: row.componentId,
+          },
+        );
+        const state = mergeResult.records[0]?.get("state") as string | undefined;
+        if (state === "created") {
+          backfilled += 1;
+          console.log(`[component-kd-backfill] convId=${row.conversationId.slice(0, 8)} componentId=${row.componentId.slice(0, 8)} outcome=created attachmentId=${attachmentId.slice(0, 8)} mimeType=${bytesPick.mimeType} bytes=${bytesPick.content.length} source=${derivedFromComponentId ? "derived" : "stamped"}`);
+        } else {
+          skipped += 1;
+          console.log(`[component-kd-backfill] convId=${row.conversationId.slice(0, 8)} componentId=${row.componentId.slice(0, 8)} outcome=skipped reason=already-projected`);
+        }
+      } catch (err) {
+        failed += 1;
+        const reason = err instanceof Error ? err.message : String(err);
+        console.log(`[component-kd-backfill] convId=${row.conversationId.slice(0, 8)} componentId=${row.componentId.slice(0, 8)} outcome=failed reason=cypher:${JSON.stringify(reason.slice(0, 200))}`);
+      }
+    }
+  } finally {
+    await session.close();
+  }
+
+  console.log(`[component-kd-backfill] summary backfilled=${backfilled} skipped=${skipped} failed=${failed}`);
+  return failed === 0 ? 0 : 1;
+}
+
+main()
+  .then((code) => process.exit(code))
+  .catch((err) => {
+    console.error(`[component-kd-backfill] crashed: ${err instanceof Error ? err.stack : String(err)}`);
+    process.exit(2);
+  });

package/payload/platform/scripts/installer-device-verify.sh

@@ -188,10 +188,18 @@ for i in $(seq 0 $((DEVICE_COUNT - 1))); do
     continue
   fi
 
-  # Step 2 — confirm CDP banner in the latest install log on the device.
-  # logs are at $HOME/<configDir>/logs/install-*.log; pick the newest by
-  # mtime (`ls -t`) and grep for the canonical success banner emitted by
-  # the installer at packages/create-maxy/src/index.ts.
+  # Step 2 — confirm a terminal-success banner in the latest install log.
+  # Pick the newest install-*.log by mtime (`ls -t`) and grep for either of
+  # the installer's two terminal-success markers emitted by
+  # packages/create-maxy/src/index.ts:
+  #   • DISPLAY_MODE=virtual (Pi, headless VNC) →
+  #     "Browser automation ready (CDP connected)"  (index.ts:3012)
+  #   • DISPLAY_MODE=native  (laptop, on-demand Chromium) →
+  #     "[cdp-check] skipped reason=native-display"  (index.ts:3004)
+  # Both terminate the install successfully; either is a pass. Hard-coding
+  # only the virtual-mode banner would mark every laptop install FAIL even
+  # though the laptop install correctly skips CDP probing because there is
+  # no persistent Chromium running for CDP to talk to.
   REMOTE_CHECK=$(cat <<'REMOTE'
 set -euo pipefail
 LOG_DIR="$HOME/__CONFIGDIR__/logs"
@@ -202,6 +210,11 @@ if [[ -z "${LATEST:-}" ]]; then
 fi
 echo "log=$LATEST"
 if grep -F -q "Browser automation ready (CDP connected)" "$LATEST"; then
+  echo "marker=cdp-connected"
+  exit 0
+fi
+if grep -F -q "[cdp-check] skipped reason=native-display" "$LATEST"; then
+  echo "marker=native-display-skip"
   exit 0
 fi
 echo "banner-not-found"

package/payload/platform/templates/specialists/agents/content-producer.md

@@ -64,9 +64,9 @@ Generate PDFs from rendered HTML pages using the browser tools.
 - **Document structure:** Cover (full-bleed, print image fallback, `page-break-after: always`) > Optional TOC > Content (flowing) > Back page (mandatory for multi-page, `page-break-before: always`).
 - **Single-pager:** Fixed `width: 210mm`, `min-height: 297mm`, `margin: 0 auto` on screen. In print add `height: 297mm`, `page-break-after: always`.
 
-**Print image capture:** For cover and back page: start a local HTTP server, set viewport to element size, hide UI chrome, take screenshot of element, save PNG. These images replace glassmorphism effects in print mode.
+**Print image capture:** For cover and back page: navigate to the rendered HTML, set viewport to element size, hide UI chrome, take screenshot of element, save PNG. These images replace glassmorphism effects in print mode.
 
-**Local files:** `file://` URLs are blocked by Playwright. Start a local HTTP server and navigate to `http://localhost:8080/filename.html`.
+**Local files:** `file://` URLs are rewritten transparently by the `playwright-file-guard` PreToolUse hook — pass them directly to `browser_navigate` and the hook will spawn a loopback `python3 -m http.server` on a free port and rewrite the URL before Playwright sees it. No agent-side server management needed.
 
 ## File delivery