@woodsportal/hubspot-kit 1.0.2

package/scripts/publish-cdn-github.mjs

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+/**
+ * Publish dist/cdn to the public GitHub CDN repo and tag for jsDelivr.
+ *
+ * Auth (pick one):
+ *   PORTAL_CDN_PUBLISH_TOKEN  — GitHub PAT with repo push on the CDN repo
+ *   GITHUB_TOKEN              — same, common in CI
+ *   (none)                    — uses your local git credentials (ssh/https)
+ *
+ * Usage:
+ *   yarn build:cdn:prod && yarn publish:cdn:prod
+ *   yarn publish:cdn --dry-run
+ *   yarn publish:cdn --skip-jsdelivr-check
+ */
+import { spawnSync } from 'node:child_process'
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { loadPortalCdnConfig, jsDelivrBaseUrl, root } from './load-portal-cdn-config.mjs'
+import { resolvePortalBuildId } from './resolve-portal-build-id.mjs'
+
+const args = new Set(process.argv.slice(2))
+const dryRun = args.has('--dry-run')
+const skipJsDelivrCheck = args.has('--skip-jsdelivr-check')
+
+function log(msg) {
+  console.log(`[publish:cdn] ${msg}`)
+}
+
+function fail(msg) {
+  console.error(`[publish:cdn] ERROR: ${msg}`)
+  process.exit(1)
+}
+
+function run(cmd, cmdArgs, options = {}) {
+  const result = spawnSync(cmd, cmdArgs, {
+    stdio: 'inherit',
+    ...options,
+  })
+  if (result.status !== 0) {
+    fail(`Command failed: ${cmd} ${cmdArgs.join(' ')}`)
+  }
+}
+
+function runCapture(cmd, cmdArgs, options = {}) {
+  const result = spawnSync(cmd, cmdArgs, {
+    encoding: 'utf8',
+    ...options,
+  })
+  if (result.status !== 0) {
+    fail(`Command failed: ${cmd} ${cmdArgs.join(' ')}\n${result.stderr ?? ''}`)
+  }
+  return (result.stdout ?? '').trim()
+}
+
+function authRemote(remote, token) {
+  if (!token?.trim()) {
+    return remote
+  }
+  const t = token.trim()
+  if (remote.startsWith('https://github.com/')) {
+    return remote.replace('https://github.com/', `https://x-access-token:${t}@github.com/`)
+  }
+  if (remote.startsWith('git@github.com:')) {
+    log('Note: PORTAL_CDN_PUBLISH_TOKEN set but remote is SSH — using local SSH auth.')
+  }
+  return remote
+}
+
+function copyCdnArtifacts(sourceDir, targetDir) {
+  mkdirSync(targetDir, { recursive: true })
+  for (const entry of readdirSync(sourceDir)) {
+    const src = join(sourceDir, entry)
+    const dest = join(targetDir, entry)
+    rmSync(dest, { recursive: true, force: true })
+    cpSync(src, dest, { recursive: true })
+  }
+}
+
+function writeCdnReadme(repoRoot, buildId, config) {
+  const readmePath = join(repoRoot, 'README.md')
+  const base = jsDelivrBaseUrl(config.github, buildId, config.cdnPathInRepo)
+  const body = `# woodsportal-client-frontend-cdn
+
+Public CDN assets for the WoodsPortal HubSpot module (**Strategy B — Hybrid CDN**).
+
+**Do not edit manually.** Files are published from \`digitalwoods.io-woodsportal-client-frontend\` via \`yarn publish:cdn\`.
+
+| | |
+|---|---|
+| Latest tag | \`${buildId}\` |
+| jsDelivr base | ${base} |
+| Source repo | [digitalwoods.io-woodsportal-client-frontend](https://github.com/Digital-Woods/digitalwoods.io-woodsportal-client-frontend) (private) |
+
+## jsDelivr URLs (tag \`${buildId}\`)
+
+- \`${base}/vendor.${buildId}.js\`
+- \`${base}/app.${buildId}.js\`
+- \`${base}/app.${buildId}.css\`
+
+Published at ${new Date().toISOString()}.
+`
+  writeFileSync(readmePath, body, 'utf8')
+}
+
+async function checkJsDelivr(config, buildId, vendorFile, appFile, appCssFile) {
+  const base = jsDelivrBaseUrl(config.github, buildId, config.cdnPathInRepo)
+  for (const file of [appCssFile, vendorFile, appFile]) {
+    const url = `${base}/${file}`
+    log(`Checking jsDelivr (may take a minute on first publish): ${url}`)
+    try {
+      const res = await fetch(url, { method: 'HEAD' })
+      if (res.ok) {
+        log(`  OK ${res.status} ${file}`)
+      } else {
+        log(`  ${file} → HTTP ${res.status} (jsDelivr may still be propagating — wait 5–15 min)`)
+      }
+    } catch (err) {
+      log(`  Could not reach jsDelivr for ${file}: ${err.message}`)
+    }
+  }
+}
+
+const config = loadPortalCdnConfig()
+const buildId = resolvePortalBuildId()
+const sourceCdn = resolve(root, 'dist/cdn')
+const token = process.env.PORTAL_CDN_PUBLISH_TOKEN ?? process.env.GITHUB_TOKEN
+
+if (!existsSync(sourceCdn)) {
+  fail('dist/cdn missing — run `yarn build:cdn` first')
+}
+
+const cdnFiles = readdirSync(sourceCdn)
+const jsFiles = cdnFiles.filter((f) => f.endsWith('.js'))
+const cssFiles = cdnFiles.filter((f) => f.endsWith('.css'))
+const vendorFile = jsFiles.find((f) => f.startsWith('vendor.'))
+const appFile = jsFiles.find((f) => f.startsWith('app.'))
+const appCssFile = cssFiles.find((f) => f.startsWith('app.'))
+
+if (!vendorFile || !appFile) {
+  fail(`dist/cdn must contain vendor.*.js and app.*.js — found: ${jsFiles.join(', ') || '(none)'}`)
+}
+
+if (!appCssFile) {
+  fail(`dist/cdn must contain app.*.css — run yarn build:cdn (component styles load via require_css)`)
+}
+
+if (!vendorFile.includes(buildId) || !appFile.includes(buildId) || !appCssFile.includes(buildId)) {
+  fail(
+    `Build id mismatch: .portal-build-id is "${buildId}" but chunks are ${vendorFile}, ${appFile}, ${appCssFile}. ` +
+      'Update .portal-build-id and rebuild with `yarn build:cdn:prod` or `yarn build:cdn:dev`.',
+  )
+}
+
+const jsdelivrBase = jsDelivrBaseUrl(config.github, buildId, config.cdnPathInRepo)
+
+const appSource = readFileSync(join(sourceCdn, appFile), 'utf8')
+const bakedApis = [
+  ...new Set(
+    [...appSource.matchAll(/https:\/\/api(?:\.dev)?\.woodsportal\.com/g)].map((m) => m[0]),
+  ),
+]
+log(`  baked API URL(s): ${bakedApis.join(', ') || '(none found)'}`)
+if (bakedApis.length === 1 && bakedApis[0] === 'https://api.woodsportal.com') {
+  log('  hint: prod API in app chunk — use `yarn deploy:prod` (not deploy:dev)')
+} else if (bakedApis.length === 1 && bakedApis[0] === 'https://api.dev.woodsportal.com') {
+  log('  hint: dev API in app chunk — use `yarn deploy:dev` for HubSpot test portals')
+}
+
+log('Configuration')
+log(`  config file:     ${config.configPath ?? '(defaults)'}`)
+log(`  build id / tag:  ${buildId}`)
+log(`  GitHub (jsDelivr): ${config.github}`)
+log(`  git remote:      ${config.gitRemote}`)
+log(`  target path:     ${config.cdnPathInRepo}/`)
+log(`  jsDelivr base:   ${jsdelivrBase}`)
+
+if (dryRun) {
+  log('Dry run — would copy:')
+  for (const f of readdirSync(sourceCdn)) {
+    log(`  dist/cdn/${f} → ${config.cdnPathInRepo}/${f}`)
+  }
+  log(`Would commit, tag ${buildId}, and push to ${config.defaultBranch}`)
+  process.exit(0)
+}
+
+const workDir = resolve(root, '.cache/portal-cdn-repo')
+rmSync(workDir, { recursive: true, force: true })
+mkdirSync(workDir, { recursive: true })
+
+const remote = authRemote(config.gitRemote, token)
+const branch = config.defaultBranch
+
+log(`Cloning ${config.gitRemote} …`)
+const cloneResult = spawnSync(
+  'git',
+  ['clone', '--depth', '1', '--branch', branch, remote, workDir],
+  { stdio: 'pipe', encoding: 'utf8' },
+)
+
+if (cloneResult.status !== 0) {
+  log('Repo empty or branch missing — initializing a fresh checkout.')
+  rmSync(workDir, { recursive: true, force: true })
+  const bareClone = spawnSync('git', ['clone', remote, workDir], {
+    stdio: 'pipe',
+    encoding: 'utf8',
+  })
+  if (bareClone.status !== 0) {
+    mkdirSync(workDir, { recursive: true })
+    run('git', ['init'], { cwd: workDir })
+    run('git', ['remote', 'add', 'origin', remote], { cwd: workDir })
+  }
+  run('git', ['checkout', '-B', branch], { cwd: workDir })
+}
+
+const targetCdnDir = resolve(workDir, config.cdnPathInRepo)
+copyCdnArtifacts(sourceCdn, targetCdnDir)
+writeCdnReadme(workDir, buildId, config)
+
+run('git', ['add', '-A'], { cwd: workDir })
+
+const status = runCapture('git', ['status', '--porcelain'], { cwd: workDir })
+if (!status) {
+  log('No file changes in CDN repo — tag may already exist. Attempting tag push only.')
+} else {
+  run(
+    'git',
+    ['commit', '-m', `release: ${buildId} portal CDN assets`],
+    { cwd: workDir },
+  )
+}
+
+const existingTag = spawnSync('git', ['rev-parse', buildId], {
+  cwd: workDir,
+  stdio: 'pipe',
+  encoding: 'utf8',
+})
+
+if (existingTag.status === 0) {
+  log(`Tag ${buildId} already exists locally — deleting and recreating on current commit.`)
+  run('git', ['tag', '-d', buildId], { cwd: workDir })
+}
+
+run('git', ['tag', '-a', buildId, '-m', `WoodsPortal CDN ${buildId}`], { cwd: workDir })
+run('git', ['push', '-u', 'origin', branch], { cwd: workDir })
+run('git', ['push', 'origin', `refs/tags/${buildId}`, '--force'], { cwd: workDir })
+
+log('')
+log('Published successfully.')
+log(`  GitHub: https://github.com/${config.github}/tree/${buildId}/${config.cdnPathInRepo}`)
+log(`  jsDelivr vendor: ${jsdelivrBase}/${vendorFile}`)
+log(`  jsDelivr app:    ${jsdelivrBase}/${appFile}`)
+log(`  jsDelivr css:    ${jsdelivrBase}/${appCssFile}`)
+log('')
+log('Next steps:')
+log('  1. Wait ~5–15 minutes for jsDelivr to index the new tag (first publish can be slower).')
+log('  2. yarn build:hubspot:dev   # dev API + jsDelivr URLs')
+log('     yarn build:hubspot:prod   # prod API')
+log('  3. yarn upload:hubspot')
+log('  Or: yarn deploy:dev  |  yarn deploy:prod')
+
+if (!skipJsDelivrCheck) {
+  await checkJsDelivr(config, buildId, vendorFile, appFile, appCssFile)
+}

package/scripts/read-woodsportal-config.mjs

@@ -0,0 +1,40 @@
+/**
+ * Read project config JSON for build/watch scripts (no zod — scripts only).
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { findProjectRootWithConfig, resolveProjectConfigPath } from './config-files.mjs'
+import { wphsPaths } from './wphs-paths.mjs'
+
+/**
+ * @param {string} [projectRoot]
+ */
+export function readWoodsportalConfig(projectRoot) {
+  const root = projectRoot ?? findProjectRootWithConfig()
+  const configPath = resolveProjectConfigPath(root)
+  if (!configPath || !existsSync(configPath)) {
+    return { root, configPath: null, config: null, paths: wphsPaths(root) }
+  }
+  const config = JSON.parse(readFileSync(configPath, 'utf8'))
+  return { root, configPath, config, paths: wphsPaths(root) }
+}
+
+export function moduleOutDir(projectRoot) {
+  const { root, config } = readWoodsportalConfig(projectRoot)
+  return resolve(root, config?.module?.outDir ?? 'dist/WoodsPortal.Module')
+}
+
+export function moduleUploadPath(projectRoot) {
+  const { config } = readWoodsportalConfig(projectRoot)
+  return config?.module?.uploadPath ?? 'dw-modules/woodsportal-module.module'
+}
+
+export function themeUploadPath(projectRoot) {
+  const { root, config } = readWoodsportalConfig(projectRoot)
+  const srcDir = config?.theme?.srcDir ?? 'src/theme'
+  return {
+    srcDir: resolve(root, srcDir),
+    uploadPath: config?.theme?.uploadPath ?? 'themes/my-theme',
+  }
+}

package/scripts/resolve-cdn-base-url.mjs

@@ -0,0 +1,32 @@
+/**
+ * Resolve CDN base URL from env (jsDelivr GitHub, custom, or local).
+ */
+import { loadPortalCdnConfig } from './load-portal-cdn-config.mjs'
+import { portalBuildId, resolvePortalBuildId } from './resolve-portal-build-id.mjs'
+
+export { portalBuildId, resolvePortalBuildId }
+
+export function resolveCdnBaseUrl(env = process.env) {
+  const config = loadPortalCdnConfig(env)
+  const explicit = env.VITE_PORTAL_CDN_BASE_URL?.replace(/\/$/, '')
+  if (explicit) {
+    return explicit
+  }
+
+  const mode = config.publishMode
+  const buildId = resolvePortalBuildId(env)
+
+  if (mode === 'local') {
+    const port = env.VITE_PORTAL_CDN_LOCAL_PORT ?? '4173'
+    return `http://localhost:${port}/dist/cdn`
+  }
+
+  if (mode === 'custom') {
+    throw new Error(
+      'VITE_PORTAL_CDN_PUBLISH_MODE=custom requires VITE_PORTAL_CDN_BASE_URL',
+    )
+  }
+
+  const cdnPath = config.cdnPathInRepo.replace(/^\//, '').replace(/\/$/, '')
+  return `https://cdn.jsdelivr.net/gh/${config.github}@${buildId}/${cdnPath}`
+}

package/scripts/resolve-consumer-dep.mjs

@@ -0,0 +1,25 @@
+/**
+ * Resolve and import packages from the consumer project (woodscli.json root).
+ * Kit scripts live under @woodsportal/hubspot-kit; Vite/React plugins are consumer deps.
+ */
+import { createRequire } from 'node:module'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { findProjectRoot } from './project-root.mjs'
+
+/**
+ * @param {string} specifier - package name or subpath export
+ */
+export function resolveConsumerDep(specifier) {
+  const root = findProjectRoot()
+  const require = createRequire(resolve(root, 'package.json'))
+  return require.resolve(specifier)
+}
+
+/**
+ * @param {string} specifier
+ */
+export async function importConsumerDep(specifier) {
+  const resolved = resolveConsumerDep(specifier)
+  return import(pathToFileURL(resolved).href)
+}

package/scripts/resolve-portal-build-id.mjs

@@ -0,0 +1,67 @@
+/**
+ * Single source of truth for PORTAL_BUILD_ID (CDN chunk filenames + jsDelivr pin).
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { findProjectRoot } from './project-root.mjs'
+import { resolveProjectConfigPath } from './config-files.mjs'
+
+let cached
+
+function getBuildIdFilePath(projectRoot) {
+  const configPath = resolveProjectConfigPath(projectRoot)
+  if (configPath) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, 'utf8'))
+      if (config.cdn?.buildIdFile) {
+        return resolve(projectRoot, config.cdn.buildIdFile)
+      }
+    } catch {
+      // ignore invalid config
+    }
+  }
+  return resolve(projectRoot, '.portal-build-id')
+}
+
+function readBuildIdFile(projectRoot) {
+  const buildIdFile = getBuildIdFilePath(projectRoot)
+  if (!existsSync(buildIdFile)) {
+    return undefined
+  }
+  const line = readFileSync(buildIdFile, 'utf8')
+    .split('\n')
+    .map((l) => l.trim())
+    .find((l) => l.length > 0 && !l.startsWith('#'))
+  return line || undefined
+}
+
+/**
+ * @param {NodeJS.ProcessEnv} [env]
+ */
+export function resolvePortalBuildId(env = process.env) {
+  if (env.PORTAL_BUILD_ID?.trim()) {
+    return env.PORTAL_BUILD_ID.trim()
+  }
+  if (env.GITHUB_REF_NAME?.trim()) {
+    return env.GITHUB_REF_NAME.trim()
+  }
+  const projectRoot = findProjectRoot()
+  return readBuildIdFile(projectRoot) ?? 'dev'
+}
+
+/** Cached build id for the current Node process (file + env read once). */
+export function portalBuildId() {
+  if (cached === undefined) {
+    cached = resolvePortalBuildId()
+  }
+  return cached
+}
+
+/** Inject resolved id into env for child processes (vite, etc.). */
+export function envWithPortalBuildId(baseEnv = process.env) {
+  const buildId = resolvePortalBuildId(baseEnv)
+  return { ...baseEnv, PORTAL_BUILD_ID: buildId }
+}
+
+export { getBuildIdFilePath as buildIdFile }

package/scripts/run-dev.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Local dev server — loads Vite and plugins from the consumer project's node_modules
+ * (configFile: false) so the kit does not need its own vite install.
+ */
+import { createRequire } from 'node:module'
+import { dirname, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { findProjectRoot, getKitRoot } from './project-root.mjs'
+
+const projectRoot = findProjectRoot()
+const kitRoot = getKitRoot()
+const require = createRequire(pathToFileURL(resolve(projectRoot, 'package.json')))
+
+const port = Number(process.env.WP_HS_DEV_PORT ?? process.argv[2] ?? 3000)
+
+const { createServer } = require('vite')
+const viteReact = require('@vitejs/plugin-react')
+const { TanStackRouterVite } = require('@tanstack/router-plugin/vite')
+const tailwindcss = require('@tailwindcss/vite')
+
+const tailwindPrefixPlugin = (
+  await import(pathToFileURL(resolve(kitRoot, 'scripts/tailwind/prefix-plugin.js')).href)
+).default
+const TailwindContentPlugin = (
+  await import(pathToFileURL(resolve(kitRoot, 'scripts/tailwind/tailwind-content-plugin.js')).href)
+).default
+const sdkLogBridge = (
+  await import(pathToFileURL(resolve(kitRoot, 'scripts/vite/sdk-log-bridge.js')).href)
+).default
+const moduleConfigStore = (
+  await import(pathToFileURL(resolve(kitRoot, 'scripts/vite/module-config-store.js')).href)
+).default
+const resolveFromProjectRoot = (
+  await import(pathToFileURL(resolve(kitRoot, 'scripts/vite/resolve-from-project-root.js')).href)
+).default
+const { createDevReactPluginOptions } = await import(
+  pathToFileURL(resolve(kitRoot, 'scripts/vite/react-dev-plugin-options.js')).href
+)
+const { ensureDevKitShims } = await import(
+  pathToFileURL(resolve(kitRoot, 'scripts/vite/ensure-dev-kit-shims.js')).href
+)
+const isPrefix = (await import(pathToFileURL(resolve(kitRoot, 'scripts/tailwind/prefix.env.js')).href))
+  .default
+
+const { moduleConfigRoot, bootstrapShim } = ensureDevKitShims(projectRoot, kitRoot)
+
+const server = await createServer({
+  root: projectRoot,
+  configFile: false,
+  mode: 'dev',
+  plugins: [
+    resolveFromProjectRoot(projectRoot, kitRoot),
+    sdkLogBridge(),
+    moduleConfigStore(projectRoot),
+    TanStackRouterVite({ autoCodeSplitting: false }),
+    viteReact.default?.(createDevReactPluginOptions()) ?? viteReact(createDevReactPluginOptions()),
+    tailwindcss.default?.() ?? tailwindcss(),
+    ...(isPrefix('dev') ? [tailwindPrefixPlugin(), TailwindContentPlugin()] : []),
+  ],
+  resolve: {
+    preserveSymlinks: true,
+    alias: {
+      '@/dev/module-config': moduleConfigRoot,
+      '@woodsportal/hubspot-kit/dev/bootstrap': bootstrapShim,
+      '@': resolve(projectRoot, './src'),
+    },
+  },
+  optimizeDeps: {
+    include: [
+      'react/compiler-runtime',
+      'react/jsx-dev-runtime',
+      'react/jsx-runtime',
+      'react-dom/client',
+    ],
+    exclude: ['woodsportal-client-sdk', 'woodsportal-client-sdk/auth', 'woodsportal-client-sdk/crm'],
+  },
+  define: {
+    'process.env.NODE_ENV': JSON.stringify('development'),
+    'process.env': {},
+    process: JSON.stringify({ env: {} }),
+  },
+  server: {
+    port,
+    fs: {
+      allow: [projectRoot, kitRoot],
+    },
+  },
+})
+
+await server.listen()
+server.printUrls()

package/scripts/run-hubspot-module-postbuild.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * HubSpot module post-build runner — invoked after `vite build` completes.
+ * Kept separate from Vite closeBundle to avoid hook-order races on CI.
+ */
+import { fileURLToPath } from 'node:url'
+import { findProjectRoot } from './project-root.mjs'
+import { dirname, resolve } from 'node:path'
+import { finalizeHubSpotModuleDist } from './hubspot-module-postbuild.mjs'
+
+const root = findProjectRoot()
+const { jsBytes, cssBytes } = finalizeHubSpotModuleDist(
+  resolve(root, 'dist/WoodsPortal.Module'),
+  resolve(root, 'public'),
+)
+
+console.log(
+  `[hubspot-module] post-build OK — module.js ${(jsBytes / 1024 / 1024).toFixed(2)} MiB, module.css ${(cssBytes / 1024).toFixed(0)} KiB`,
+)

package/scripts/run-vite-build.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * Run `vite build` with portal env — `.env.stg` / `.env.prod` take precedence over shell.
+ *
+ * Usage: node scripts/run-vite-build.mjs <vite-config.mjs> [--stg]
+ */
+import { spawnSync } from 'node:child_process'
+
+import { defaultDatadogFlag, envForPortalBuild } from './portal-vite-env.mjs'
+import { resolvePortalViteMode } from './portal-env-mode.mjs'
+import { findProjectRoot } from './project-root.mjs'
+
+const root = findProjectRoot()
+const config = process.argv[2]
+const mode = resolvePortalViteMode()
+
+if (!config) {
+  console.error('Usage: node scripts/run-vite-build.mjs <vite-config.mjs> [--stg]')
+  process.exit(1)
+}
+
+const env = envForPortalBuild(mode, root, {
+  VITE_DATADOG_RUM_ENABLED: defaultDatadogFlag(mode),
+  WP_HS_PROJECT_ROOT: root,
+})
+
+const result = spawnSync(
+  'npx',
+  ['vite', 'build', '--config', config, '--mode', mode],
+  { cwd: root, stdio: 'inherit', env, shell: true },
+)
+
+process.exit(result.status ?? 1)