dsh-creator-mode-plus 0.3.8

package/scripts/verify-harness-install.mjs

@@ -0,0 +1,101 @@
+import { createHash } from 'node:crypto'
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  statSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { installCreatorModePlus, standardPresetAt } from './install.mjs'
+
+function digest(path) {
+  return createHash('sha256').update(readFileSync(path)).digest('hex')
+}
+
+function parseArguments(argv) {
+  let harnessRoot
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index]
+    if (token === '--harness') {
+      const value = argv[index + 1]
+      if (!value || value.startsWith('--') || harnessRoot) throw new Error('--harness requires exactly one path')
+      harnessRoot = resolve(value)
+      index += 1
+    } else if (token === '--help' || token === '-h') {
+      return { help: true }
+    } else {
+      throw new Error(`unknown option: ${token}`)
+    }
+  }
+  if (!harnessRoot) throw new Error('--harness is required for RC2 install verification')
+  return { harnessRoot }
+}
+
+/** Exercise the real shipped Standard preset in an isolated disposable DSH_HOME. */
+export function verifyHarnessInstall(harnessRoot) {
+  const standardPreset = standardPresetAt(harnessRoot)
+  const sourceComposition = join(standardPreset, 'agent.cordis.yml')
+  const sourcePreset = join(standardPreset, 'preset.yml')
+  const before = {
+    composition: digest(sourceComposition),
+    preset: digest(sourcePreset),
+  }
+  const dshHome = mkdtempSync(join(tmpdir(), 'creator-mode-plus-rc2-install-'))
+  try {
+    const installed = installCreatorModePlus({ harnessRoot, dshHome })
+    const compositionPath = join(installed.target, 'agent.cordis.yml')
+    const skillPath = join(installed.target, 'skills/creator-mode-plus/SKILL.md')
+    const composition = readFileSync(compositionPath, 'utf8')
+    const skill = readFileSync(skillPath, 'utf8')
+    if (!composition.includes('You are Creator Mode+')) throw new Error('isolated preset is missing the Creator Mode+ persona')
+    if (!composition.includes('name: dsh-creator-mode-plus')) throw new Error('isolated preset is missing the standalone bridge row')
+    if (!skill.includes('dshx_status') || !skill.includes('dshx_hot_reload')) throw new Error('isolated preset is missing the Creator delivery workflow')
+    const maintenance = readFileSync(join(installed.target, 'skills/creator-mode-plus/maintenance.md'), 'utf8')
+    if (!skill.includes('(maintenance.md#harness-and-launcher-maintenance)') || !maintenance.includes('update plan → prepare → verify → apply')) throw new Error('isolated preset is missing the referenced Harness maintenance branch')
+    if (!existsSync(join(installed.target, 'skills/creator-mode-plus/verification-recovery.md'))) throw new Error('isolated preset is missing the referenced verification branch')
+
+    const firstStamp = statSync(compositionPath)
+    const updated = installCreatorModePlus({ harnessRoot, dshHome, upgrade: true })
+    const secondStamp = statSync(compositionPath)
+    if (firstStamp.size !== secondStamp.size || firstStamp.mtimeMs !== secondStamp.mtimeMs) {
+      throw new Error('managed asset refresh changed the unchanged agent.cordis.yml stamp')
+    }
+    if (!existsSync(skillPath)) throw new Error('managed upgrade removed the Creator Mode+ skill')
+    if (digest(sourceComposition) !== before.composition || digest(sourcePreset) !== before.preset) {
+      throw new Error('isolated install changed a shipped Harness preset')
+    }
+
+    return Object.freeze({
+      ok: true,
+      harnessRoot,
+      dshxVersion: updated.dshxVersion,
+      creatorBridgeVersion: updated.creatorBridgeVersion,
+      dshxContract: updated.dshxContract,
+      freshInstall: installed.action,
+      managedUpgrade: updated.action,
+      shippedPresetUnchanged: true,
+      compositionStampStable: true,
+    })
+  } finally {
+    rmSync(dshHome, { recursive: true, force: true })
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    const options = parseArguments(process.argv.slice(2))
+    if (options.help) {
+      process.stdout.write('Usage: node scripts/verify-harness-install.mjs --harness /absolute/path/to/deepseek-harness\n')
+    } else {
+      const result = verifyHarnessInstall(options.harnessRoot)
+      process.stdout.write('CREATOR_MODE_PLUS_HARNESS_INSTALL_COMPATIBILITY_PASS\n')
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`)
+    }
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`)
+    process.exitCode = 1
+  }
+}

package/src/auth.js

@@ -0,0 +1,26 @@
+/** Validate only the official current-Host launch URL; never surface its value. */
+export function privateStartupUrl(getUrl, port) {
+  if (getUrl === undefined) return ''
+  let value
+  try { value = getUrl(port) } catch { throw new Error('WEB_AUTH_HANDOFF_FAILED: official Connection startup handoff failed') }
+  if (value === undefined || value === '') return '' // older unauthenticated Web
+  try {
+    const url = new URL(value)
+    if (url.origin !== `http://127.0.0.1:${port}` || url.username || url.password
+      || url.pathname !== '/' || url.hash || [...url.searchParams.keys()].some(key => key !== 'token')
+      || url.searchParams.getAll('token').length > 1 || (url.searchParams.has('token') && !url.searchParams.get('token'))) throw new Error()
+    return url.href
+  } catch { throw new Error('WEB_AUTH_ORIGIN_MISMATCH: official handoff must target the current loopback Host') }
+}
+
+/** Redact after stream assembly so secrets split across output chunks stay private. */
+export function redactStartupOutput(text, startup) {
+  if (!startup) return text
+  let result = text.split(startup).join('<redacted-startup-url>')
+  const token = new URL(startup).searchParams.get('token')
+  if (token) {
+    result = result.split(token).join('<redacted-token>')
+    result = result.split(encodeURIComponent(token)).join('<redacted-token>')
+  }
+  return result
+}

package/src/client.js

@@ -0,0 +1,112 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-creator-mode-plus',
+  factory: () => {
+    const name = 'dsh-creator-mode-plus-client'
+    const inject = ['loader']
+    const endpoint = '/dsh-creator-mode-plus/client-failure'
+    const fuseKey = 'dsh-creator-mode-plus:last-client-failure'
+
+    function failedEntries(ctx) {
+      const ids = []
+      for (const entry of ctx.loader.entries()) {
+        const state = entry.fiber?.state
+        if (state !== 2) ids.push(entry.options.name)
+      }
+      return [...new Set(ids)].sort()
+    }
+
+    function bootFailureText() {
+      const boot = document.querySelector('[data-dsh-boot]')
+      const text = boot?.textContent || ''
+      return text.includes('Failed to load plugins') ? text.slice(0, 8000) : undefined
+    }
+
+    function apply(ctx) {
+      let disposed = false
+      let reporting = false
+      let timer
+      let retryCount = 0
+      let sawBootPage = Boolean(document.querySelector('[data-dsh-boot]'))
+
+      const clearFuseWhenMounted = () => {
+        if (document.querySelector('[data-dsh-boot]')) {
+          sawBootPage = true
+        } else if (sawBootPage) {
+          sessionStorage.removeItem(fuseKey)
+          sawBootPage = false
+          retryCount = 0
+        }
+      }
+
+      const report = async (message, exactId) => {
+        if (disposed || reporting) return
+        const failedIds = exactId ? [exactId] : failedEntries(ctx)
+        if (failedIds.length === 0) return
+        const signature = JSON.stringify(failedIds)
+        if (sessionStorage.getItem(fuseKey) === signature) return
+        reporting = true
+        sessionStorage.setItem(fuseKey, signature)
+        try {
+          const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ failedIds, message: String(message || '').slice(0, 8000) }),
+          })
+          const result = await response.json()
+          if (response.ok && result.reload === true && !disposed) {
+            location.reload()
+            return
+          }
+          if (!disposed && retryCount < 1) {
+            retryCount += 1
+            setTimeout(() => {
+              sessionStorage.removeItem(fuseKey)
+              void report(message, exactId)
+            }, 2_000)
+          }
+        } catch (error) {
+          console.warn('Creator Mode+ could not report the client-loader failure', error)
+          if (!disposed && retryCount < 1) {
+            retryCount += 1
+            setTimeout(() => {
+              sessionStorage.removeItem(fuseKey)
+              void report(message, exactId)
+            }, 2_000)
+          }
+        } finally {
+          reporting = false
+        }
+      }
+
+      const scan = () => {
+        clearFuseWhenMounted()
+        const message = bootFailureText()
+        if (message) void report(message)
+      }
+      const scheduleScan = () => {
+        clearTimeout(timer)
+        timer = setTimeout(scan, 250)
+      }
+
+      ctx.on('internal/status', (fiber) => {
+        const id = fiber.entry?.options?.name
+        if (fiber.state === 3 && typeof id === 'string') {
+          void report(`client loader entry ${id} entered FAILED`, id)
+        } else {
+          scheduleScan()
+        }
+      })
+
+      const observer = new MutationObserver(scheduleScan)
+      observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true })
+      scheduleScan()
+      ctx.effect(() => () => {
+        disposed = true
+        clearTimeout(timer)
+        observer.disconnect()
+      }, 'Creator Mode+ browser failure sentry')
+    }
+
+    return { name, inject, apply }
+  },
+})

package/src/compatibility.js

@@ -0,0 +1,261 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+export const CREATOR_BRIDGE_VERSION = 2
+
+export const DSHX_CONTRACT = Object.freeze({
+  id: 'dshx-v0.7/creator-bridge-v2',
+  release: 'v0.7.8',
+  minimum: '0.7.8',
+  maximumExclusive: '0.8.0',
+  capabilities: Object.freeze([
+    'creator-session-claims',
+    'human-confirmed-creator-takeover',
+    'workspace-scaffold',
+    'bounded-new-client-activation',
+    'authenticated-host-proof',
+    'private-browser-handoff',
+    'session-browser-open',
+    'safe-plugin-removal',
+    'safe-profile-bundle-removal',
+    'external-guardian-recovery',
+    'proactive-plugin-integrity-quarantine',
+    'same-pid-activation-matrix',
+    'bounded-same-pid-server-hot-reload',
+    'single-home-web-host',
+    'isolated-verify-home',
+    'transactional-harness-update-assistant',
+  ]),
+})
+
+export const SUPPORTED_DSHX = Object.freeze({
+  minimum: DSHX_CONTRACT.minimum,
+  maximumExclusive: DSHX_CONTRACT.maximumExclusive,
+})
+
+export const CREATOR_MODEL_TOOLS = Object.freeze([
+  'dshx_claim_plugin',
+  'dshx_request_takeover',
+  'dshx_scaffold',
+  'dshx_check',
+  'dshx_activation_plan',
+  'dshx_activate_new_client',
+  'dshx_remove_plugin',
+  'dshx_hot_reload',
+  'dshx_browser_open',
+  'dshx_status',
+])
+
+export const DSHX_SURFACE_MARKERS = Object.freeze({
+  'src/internal/creator-claims.mjs': Object.freeze(['beginTakeover', 'commitTakeover', 'CREATOR_TAKEOVER_GRANT_REQUIRED', 'revocations']),
+  'src/creator-plus/takeover.js': Object.freeze(['userQuestions', 'ensureTakeoverFence', 'CREATOR_OWNER_NOT_QUIESCENT']),
+  'src/internal/browser-access.ts': Object.freeze(['bindBrowserAccess', 'assertSameBrowserHost', 'BROWSER_ADAPTER_REQUIRED', 'configureSessionBrowserAdapter', 'sessionBrowserAdapter']),
+  'src/commands/browser.ts': Object.freeze(['cmdBrowser', 'HTTP_AUTHENTICATED']),
+  'src/internal/web-proof-auth.ts': Object.freeze(['createWebProofRequest', 'WEB_AUTH_REQUIRED', 'WEB_AUTH_ORIGIN_MISMATCH']),
+  'src/cli.ts': Object.freeze([
+    "case 'check'",
+    "case 'status'",
+    "case 'activation-plan'",
+    "case 'activate-new-client'",
+    "case 'hot-reload'",
+    "case 'creator'",
+    "case 'browser'",
+    "case 'plugin'",
+    "case 'update'",
+  ]),
+  'src/commands/activation.ts': Object.freeze([
+    '--change patch|manifest|preset|client|new-client|server|artifact',
+    'activationDecision(options.change, facts)',
+  ]),
+  'src/commands/check.ts': Object.freeze(['checkPlugin(loadPlugin(root, name), root)']),
+  'src/commands/creator.ts': Object.freeze([
+    "action === 'claim'",
+    "action === 'scaffold'",
+    "action === 'remove'",
+    "action === 'client-failure'",
+    'recoverCreatorClientFailure(root, failure)',
+  ]),
+  'src/commands/new-client.ts': Object.freeze(['SOURCE_BUILT', 'CLIENT_MANIFEST_PRESENT']),
+  'src/commands/hot-reload.ts': Object.freeze([
+    'hotReloadPlugin',
+    'HOST_MODULE_RELOADED',
+    'behaviorVerified: false',
+  ]),
+  'src/commands/plugin.ts': Object.freeze([
+    "action !== 'remove'",
+    'HOST_TREE_INACTIVE',
+    'PROFILE_DEPENDENCY_REMOVED',
+  ]),
+  'src/commands/update.ts': Object.freeze([
+    'dshx update plan|prepare|verify|apply|rollback',
+    "action === 'apply' || action === 'rollback'",
+  ]),
+  'src/internal/creator.ts': Object.freeze(['bridgeVersion !== 2', 'workspaceRoot']),
+  'src/internal/guardian.ts': Object.freeze([
+    'export function armGuardian',
+    'export async function recoverCreatorClientFailure',
+    'export async function runGuardianCycle',
+    "reason: 'crash-loop'",
+    "reason: 'plugin-integrity-failed'",
+  ]),
+  'src/internal/remove-plugin.ts': Object.freeze([
+    'HOST_TREE_INACTIVE',
+    'official dsh plugin remove',
+    'Source is never',
+  ]),
+  'src/internal/profile-plugin-remove.ts': Object.freeze([
+    'current __DSH_BOOT__ has no same-name Loader id',
+    'HOST_TREE_INACTIVE was not proved',
+    'official dsh plugin remove failed',
+    'retained-until-next-boot',
+  ]),
+  'src/internal/io.ts': Object.freeze(["command === 'update'", "args[0] ?? 'plan'"]),
+  'src/internal/new-client.ts': Object.freeze([
+    'BOOT_MANIFEST_ASSIGNMENT',
+    'window.__DSH_BOOT__',
+    'globalThis["__DSH_BOOT__"]',
+    'no supported __DSH_BOOT__ manifest assignment',
+  ]),
+  'src/internal/hot-reload.ts': Object.freeze([
+    'export async function hotReloadPlugin',
+    'artifactHashes',
+    'targetScope',
+    'bytesUnchanged: true',
+    'cleanupProved: true',
+  ]),
+  'src/internal/hot-reload-journal.ts': Object.freeze([
+    "kind: 'server-hot-reload'",
+    'automaticRecovery: false',
+    'writeHotReloadJournal',
+  ]),
+  'src/runtime/hot-reload-observer.mjs': Object.freeze([
+    "ctx.on('hmr/reload'",
+    "publish('MODULE_RELOADED'",
+    'targetGenerationStates',
+    "publish('OBSERVER_DISPOSED'",
+  ]),
+  'src/runtime/hot-reload-hmr-audit.mjs': Object.freeze([
+    'export async function auditActiveHmr',
+    'could not resolve the official HMR runtime',
+    'another watcher overlapping targetFiles',
+  ]),
+  'src/internal/host-discovery.ts': Object.freeze([
+    'discoverWebHosts',
+    'parseWebProcessTable',
+    'assertNoAffectedWebHosts',
+    'processStartedAt',
+    'process table unavailable',
+  ]),
+  'src/internal/host.ts': Object.freeze([
+    'acquireWebHostOperationLock',
+    'processStartedAt',
+    'export function probePid',
+    "'ESRCH'",
+    'export async function probePort',
+    "'ECONNREFUSED'",
+  ]),
+  'src/commands/host.ts': Object.freeze([
+    'shared-home-collision',
+    'already-attached',
+    'proveSpawnedWebHost',
+    'dshx-verify-home-',
+    '--keep is not available for isolated verification',
+  ]),
+  'src/internal/update-apply.ts': Object.freeze([
+    'assertNoAffectedWebHosts',
+    'withUpdateHostGuard',
+    'update apply',
+    'update rollback',
+  ]),
+  'knowledge/contracts/creator-mode-plus.md': Object.freeze([
+    'creator claim',
+    'creator scaffold',
+    'creator remove',
+    'activate-new-client',
+  ]),
+  'knowledge/contracts/creator-guardian.md': Object.freeze(['Creator+', 'crash-loop fuse', 'quarantine', 'plugin-integrity-failed']),
+  'knowledge/contracts/harness-update.md': Object.freeze(['plan → prepare → verify → apply', 'rollback']),
+  'knowledge/contracts/live-activation.md': Object.freeze(['SOURCE_BUILT', 'CLIENT_MANIFEST_PRESENT']),
+  'knowledge/contracts/compat-0.1.5.md': Object.freeze(['MarkdownText', 'createDrafts', 'assistant/attempt.stream']),
+  'src/internal/compat-015.ts': Object.freeze(['compat-015-message-text', 'compat-015-ctx-agent']),
+  'knowledge/playbooks/verify-boot.md': Object.freeze(['临时 `DSH_HOME`', '`--keep` 会被拒绝']),
+  'skill/dshx/SKILL.md': Object.freeze(['Treat DSH.app, direct `dsh web`', '`--keep` is unsafe and', 'PID-reused is reported as stale']),
+})
+
+export const REQUIRED_DSHX_PATHS = Object.freeze(Object.keys(DSHX_SURFACE_MARKERS))
+
+function parseVersion(value) {
+  if (typeof value !== 'string') return undefined
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value)
+  if (!match) return undefined
+  return {
+    parts: match.slice(1, 4).map(Number),
+    prerelease: match[4] !== undefined,
+  }
+}
+
+function compareVersions(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    if (left[index] !== right[index]) return left[index] - right[index]
+  }
+  return 0
+}
+
+/** Return whether a stable DSHX release implements the complete v0.7 contract. */
+export function supportsDshxVersion(version) {
+  const parsed = parseVersion(version)
+  const minimum = parseVersion(DSHX_CONTRACT.minimum)
+  const maximum = parseVersion(DSHX_CONTRACT.maximumExclusive)
+  return Boolean(parsed)
+    && parsed.prerelease === false
+    && compareVersions(parsed.parts, minimum.parts) >= 0
+    && compareVersions(parsed.parts, maximum.parts) < 0
+}
+
+/** Fail closed unless one Harness checkout carries the full DSHX v0.7 contract. */
+export function inspectDshxCompatibility(harnessRoot) {
+  const root = resolve(harnessRoot)
+  const dshxRoot = join(root, 'tools/dshx')
+  const packagePath = join(dshxRoot, 'package.json')
+  let metadata
+  try {
+    metadata = JSON.parse(readFileSync(packagePath, 'utf8'))
+  } catch (error) {
+    throw new Error(`dsh-creator-mode-plus: cannot read DSHX package metadata at ${packagePath}: ${error instanceof Error ? error.message : String(error)}`)
+  }
+  if (metadata.name !== 'dsh-external-plugin-devkit') {
+    throw new Error(`dsh-creator-mode-plus: unexpected package at ${packagePath}`)
+  }
+  if (!supportsDshxVersion(metadata.version)) {
+    throw new Error(
+      `dsh-creator-mode-plus: dshx ${metadata.version ?? 'unknown'} is incompatible; `
+      + `contract ${DSHX_CONTRACT.id} requires >=${DSHX_CONTRACT.minimum} <${DSHX_CONTRACT.maximumExclusive}`,
+    )
+  }
+  const missingPaths = REQUIRED_DSHX_PATHS.filter(path => !existsSync(join(dshxRoot, path)))
+  if (missingPaths.length > 0) {
+    throw new Error(
+      `dsh-creator-mode-plus: dshx ${metadata.version} is missing required ${DSHX_CONTRACT.id} surfaces: ${missingPaths.join(', ')}`,
+    )
+  }
+  const driftedSurfaces = []
+  for (const [path, markers] of Object.entries(DSHX_SURFACE_MARKERS)) {
+    const source = readFileSync(join(dshxRoot, path), 'utf8')
+    const missingMarkers = markers.filter(marker => !source.includes(marker))
+    if (missingMarkers.length > 0) driftedSurfaces.push(`${path} [${missingMarkers.join(', ')}]`)
+  }
+  if (driftedSurfaces.length > 0) {
+    throw new Error(
+      `dsh-creator-mode-plus: dshx ${metadata.version} contract drift for ${DSHX_CONTRACT.id}: ${driftedSurfaces.join('; ')}`,
+    )
+  }
+  return Object.freeze({
+    root,
+    dshxRoot,
+    packagePath,
+    dshxVersion: metadata.version,
+    creatorBridgeVersion: CREATOR_BRIDGE_VERSION,
+    contractId: DSHX_CONTRACT.id,
+    capabilities: DSHX_CONTRACT.capabilities,
+  })
+}