@deepblend/dsh-blender-ui 0.1.0 → 0.2.1

package/lib/index.js

@@ -23,6 +23,8 @@
  * Plane: Host composition (the Web Client half is `./client.js`)
  */
 
+import { homedir } from 'node:os'
+
 import { Service } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
 
@@ -39,6 +41,9 @@ import {
   buildRevisionDiff,
   buildSceneTree,
   buildSettingsCard,
+  buildDiagnosticsBundle,
+  DIAGNOSTICS_JOB_LIMIT,
+  DIAGNOSTICS_FAILURE_LIMIT,
   matchUiRoute,
   assertKnownConfigKeys,
 } from '@deepblend/dsh-blender-contracts'
@@ -46,6 +51,95 @@ import {
 /** Route path serving the settings card document (M0's surface, kept verbatim). */
 export const CAPABILITIES_ROUTE = '/deepblend/capabilities'
 
+/** Route path serving the standalone fullscreen workbench document (SPEC §20 M6). */
+export const WORKBENCH_PAGE_ROUTE = '/deepblend/workbench'
+
+/**
+ * The element the standalone page reserves for the workbench.
+ *
+ * Named once, and read by the page's own bootstrap below and by
+ * `e2e/workbench-page.e2e.mjs`, so "the page mounted something" is answered by
+ * the same string on both sides.
+ */
+export const WORKBENCH_PAGE_ROOT_ID = 'deepblend-workbench'
+
+/**
+ * The bootstrap the standalone page runs.
+ *
+ * Twelve lines, and every one of them is about ARRIVING at the bundle rather
+ * than about the workbench:
+ *
+ *   1. `__DSH_BOOT_READY__` — the tail injection, resolved once the boot rows
+ *      have run. Awaiting it is what makes this script safe wherever the
+ *      injection table happens to be spliced.
+ *   2. `create({ boot: __DSH_BOOT__, staticModules: {} })` — the SAME module
+ *      system the console builds, over the SAME graph global. The seed is empty
+ *      because this page supplies no platform modules: React is a console seed
+ *      word, the workbench core does not use it, and `client.js` reads it lazily
+ *      precisely so that this call can pass `{}`.
+ *   3. `import('@deepblend/dsh-blender-ui')` — the console's own graph row,
+ *      fetched from the console's own bundle route. There is no second copy of
+ *      the workbench anywhere for this to find.
+ *   4. `mountStandalone(root)` — the one function that differs between the faces.
+ *
+ * A failure is reported INTO the page rather than only to the console, because a
+ * blank full-screen page is indistinguishable from a page that never booted.
+ *
+ * @param {string} rootId
+ * @returns {string}
+ */
+export function workbenchPageBootstrap(rootId) {
+  return `<script>(async () => {
+  const root = document.getElementById(${JSON.stringify(rootId)})
+  try {
+    await globalThis.__DSH_BOOT_READY__?.promise
+    const modules = window.__ModuleLoader__.create({ boot: window.__DSH_BOOT__, staticModules: {} })
+    const bundle = await modules.import('@deepblend/dsh-blender-ui')
+    await bundle.mountStandalone(root)
+    root.dataset.deepblendStandalone = 'ready'
+  } catch (error) {
+    root.dataset.deepblendStandalone = 'failed'
+    root.textContent = 'DeepBlend 工作台未能启动：' + String((error && error.message) || error)
+  }
+})()</script>`
+}
+
+/**
+ * The standalone workbench document.
+ *
+ * Deliberately minimal, and deliberately NOT the console: no shell bundle, no
+ * sidebar, no conversation — one root element and the bootstrap. Everything the
+ * page shows arrives from the bundle the bootstrap imports and from the Host
+ * routes that bundle reads.
+ *
+ * `<head>` and `<body>` are present because `webServer.renderIndex` splices the
+ * boot injections into them; without the tags the rows would be prepended to the
+ * document instead, and the bootstrap script would run before the module loader
+ * existed.
+ *
+ * @param {string} rootId
+ * @param {{ title?: string }} [options]
+ * @returns {string}
+ */
+export function workbenchPageDocument(rootId, options = {}) {
+  const title = options.title ?? 'DeepBlend 工作台'
+  return [
+    '<!doctype html>',
+    '<html lang="zh">',
+    '<head>',
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width,initial-scale=1">',
+    `<title>${title}</title>`,
+    '</head>',
+    `<body style="margin:0;height:100vh">`,
+    `<div id="${rootId}" data-deepblend-standalone="loading" style="height:100vh"></div>`,
+    workbenchPageBootstrap(rootId),
+    '</body>',
+    '</html>',
+    '',
+  ].join('\n')
+}
+
 /** Service key for the UI-facing host controller. */
 export const BLENDER_UI_SERVICE = 'blenderUi'
 
@@ -96,6 +190,12 @@ export default class BlenderUiHost extends Service {
     assertKnownConfigKeys(UiConfig, config, 'deepblend-blender-ui')
     this.config = config
     this._routeDisposer = null
+    // Kept for ONE reason: the standalone page document has to be rendered
+    // through `webServer.renderIndex`, which is what splices the boot injections
+    // (`window.__ModuleLoader__`, `window.__DSH_BOOT__`, the bootstrap batch) into
+    // a body. That is the whole of this row's dependence on the server object —
+    // no file, no process, no path.
+    this._webServer = null
 
     // One handler per route id, and no other way in. A test asserts the key set
     // equals UI_ROUTES exactly, in both directions.
@@ -104,6 +204,7 @@ export default class BlenderUiHost extends Service {
     if (!config.serveRoute) return
 
     ctx.inject(['webServer'], (serverCtx) => {
+      this._webServer = serverCtx.webServer
       // Route registration belongs to this fiber, so unmounting the row removes
       // the route (SPEC §4.4 / lifecycle: every side effect is reversible).
       const dispose = serverCtx.webServer.register({
@@ -114,6 +215,7 @@ export default class BlenderUiHost extends Service {
       this._routeDisposer = dispose
       return () => {
         this._routeDisposer = null
+        this._webServer = null
         dispose()
       }
     })
@@ -156,6 +258,13 @@ export default class BlenderUiHost extends Service {
         await this._sendArtifact(request, response, matched.params)
         return
       }
+      // The second response that is not JSON, and the only one that is a
+      // document: the standalone workbench. It reads nothing from the request —
+      // no query, no body, no parameter — so there is no input here to validate.
+      if (matched.route.id === 'workbench.page') {
+        this._sendWorkbenchPage(request, response)
+        return
+      }
       const body = await readRequestBody(request)
       const result = await this._handlers[matched.route.id]({
         params: matched.params,
@@ -201,6 +310,46 @@ export default class BlenderUiHost extends Service {
     response.end(request.method === 'HEAD' ? undefined : artifact.bytes)
   }
 
+  /**
+   * Serve the standalone fullscreen workbench document (SPEC §20 M6).
+   *
+   * This is the only route that answers with HTML, and the only place in this
+   * package that asks the web server for anything other than a route seat. It
+   * reads no request input, touches no project and no path, and derives nothing
+   * from the caller: the document is a constant plus whatever the composition's
+   * own index injections add.
+   *
+   * `renderIndex` is what makes the page a real client surface rather than a
+   * static one — it splices in the boot rows (`window.__ModuleLoader__`, the
+   * `@deepseek-ai/dsh-client-modules` bootstrap, `window.__DSH_BOOT__`) that the
+   * console's own index.html gets, so the page can import this package's client
+   * bundle out of the graph instead of being handed a copy of it.
+   *
+   * When there is no web server there is no route either (the row only registers
+   * one inside `ctx.inject(['webServer'])`), so the fallback below is unreachable
+   * in a composed deployment; it exists so that driving `_handle` against a stub
+   * server in a test cannot throw on a missing method.
+   *
+   * @param {import('node:http').IncomingMessage} request
+   * @param {import('node:http').ServerResponse} response
+   */
+  _sendWorkbenchPage(request, response) {
+    const document = workbenchPageDocument(WORKBENCH_PAGE_ROOT_ID)
+    const server = this._webServer
+    const html = server !== null && typeof server.renderIndex === 'function'
+      ? server.renderIndex(document)
+      : document
+    const bytes = Buffer.from(html, 'utf8')
+    response.setHeader('content-type', 'text/html; charset=utf-8')
+    // Never cached, for the same reason the JSON routes are not: this document
+    // names the bundle revision it will load, and a cached copy would pin a page
+    // to a revision the process no longer serves.
+    response.setHeader('cache-control', 'no-store')
+    response.setHeader('content-length', String(bytes.length))
+    response.statusCode = 200
+    response.end(request.method === 'HEAD' ? undefined : bytes)
+  }
+
   /**
    * @param {import('node:http').ServerResponse} response
    * @param {number} status
@@ -332,6 +481,102 @@ export function createHandlers(ctx) {
       }
     },
 
+    /**
+     * The shareable diagnostic bundle (ledger C10).
+     *
+     * IT PROBES BLENDER, AND THAT IS THE POINT. The first question a maintainer asks about a report is
+     * "does Blender work on that machine", and a bundle that answered "not probed" would send the
+     * conversation back to the user. The probe is the same one the settings card already makes
+     * (coalesced, cached for `capabilitiesCacheMs`), and a FAILED probe is a structured value here
+     * rather than an error page — a machine without Blender is exactly the machine whose bundle
+     * somebody is about to send.
+     *
+     * `config` IS AN ALLOWLIST. Every key below is named on purpose. A spread would publish whatever
+     * configuration key is added next, and a diagnostic bundle is the last place that should happen.
+     */
+    diagnostics: async () => {
+      let capabilities = null
+      let probeError = null
+      try {
+        capabilities = await studio().describeCapabilities({})
+      } catch (cause) {
+        const error = cause instanceof BlenderError
+          ? cause
+          : new BlenderError(
+            BlenderErrorCode.CAPABILITY_PROBE_FAILED,
+            cause instanceof Error ? cause.message : String(cause),
+          )
+        probeError = { code: error.code ?? BlenderErrorCode.CAPABILITY_PROBE_FAILED, message: error.message ?? '' }
+      }
+
+      const listed = await studio().listProjects()
+      const projects = []
+      const failures = []
+      for (const record of listed.projects) {
+        const jobs = await studio().listJobs({ projectId: record.projectId })
+        const byStatus = {}
+        for (const job of jobs.jobs) byStatus[job.status] = (byStatus[job.status] ?? 0) + 1
+        const failed = jobs.jobs.filter(job => job.status === 'failed').slice(-DIAGNOSTICS_JOB_LIMIT)
+        for (const job of failed) {
+          failures.push({
+            projectId: record.projectId,
+            jobId: job.jobId,
+            type: job.type ?? null,
+            errorCode: job.errorCode ?? null,
+            message: job.error ?? null,
+            frames: job.frames ?? null,
+            updatedAt: job.updatedAt ?? null,
+          })
+        }
+        projects.push({
+          projectId: record.projectId,
+          title: record.title ?? null,
+          currentRevision: record.currentRevision ?? null,
+          revisionCount: record.revisionCount ?? 0,
+          updatedAt: record.updatedAt ?? null,
+          jobs: {
+            total: jobs.jobs.length,
+            byStatus,
+            unfinished: jobs.unfinished?.length ?? 0,
+            recoveryFindings: jobs.recovery?.length ?? 0,
+            recent: jobs.jobs.slice(-DIAGNOSTICS_JOB_LIMIT).map(job => ({
+              jobId: job.jobId,
+              type: job.type ?? null,
+              status: job.status,
+              revision: job.revision ?? null,
+              frames: job.frames ?? null,
+              errorCode: job.errorCode ?? null,
+              updatedAt: job.updatedAt ?? null,
+            })),
+          },
+        })
+      }
+
+      // The Host projects its own configuration (the keys are declared there, and this half's schema
+      // declares none of them), and the same projection supplies the workspace root below — one read,
+      // so the two fields cannot disagree about where this deployment keeps its state.
+      const projected = studio().describeConfiguration?.() ?? {}
+
+      return buildDiagnosticsBundle({
+        generatedAt: new Date().toISOString(),
+        product: { name: 'DeepBlend Studio', version: studio().productVersion?.() ?? null, hostApiVersion: HOST_API_VERSION },
+        environment: { node: process.version, platform: process.platform, arch: process.arch, home: homedir() },
+        blender: {
+          probed: true,
+          note: 'Blender was probed for this export (the same probe the settings card makes).',
+          capabilities,
+          error: probeError,
+        },
+        config: projected,
+        store: { projectsRoot: listed.projectsRoot ?? null, workspaceRoot: projected.workspaceRoot ?? null, projects },
+        failures,
+        notes: [
+          `jobs per project are capped at ${DIAGNOSTICS_JOB_LIMIT}`,
+          `failures are capped at ${DIAGNOSTICS_FAILURE_LIMIT}`,
+        ],
+      })
+    },
+
     /** Everything the panel needs to render itself from scratch, in one request. */
     state: async ({ query }) => {
       const listed = await studio().listProjects()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepblend/dsh-blender-ui",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "DeepBlend workbench UI: Host half (typed HTTP API) and Web Client half (sidebar, panels, tool cards).",
   "main": "lib/index.js",
@@ -19,7 +19,7 @@
     }
   },
   "dependencies": {
-    "@deepblend/dsh-blender-contracts": "0.1.0"
+    "@deepblend/dsh-blender-contracts": "0.2.1"
   },
   "license": "MIT",
   "repository": {