@ossy/app 1.11.0 → 1.11.2

package/README.md

@@ -23,7 +23,7 @@ export default () => <h1>About</h1>
 
 For a single-file setup, use `src/pages.jsx` (legacy).
 
-Split pages are merged into **`build/.ossy/pages.generated.jsx`** (next to other build output) during `dev` / `build`.
+During `dev` / `build`, the tooling writes **JSON manifests** under **`build/.ossy/`**: **`pages.generated.json`** (route ids, default paths, and `sourceFile` paths), **`pages.bundle.json`** (compiled `page-modules/<id>.mjs` paths), plus the same pattern for API and tasks (`*.generated.json` / `*.bundle.json`). Small **`*.runtime.mjs`** loaders (copied from `@ossy/app`) dynamically `import()` those compiled modules at runtime.
 
 **Client JS (per-page):** For each `*.page.jsx`, the build emits **`build/.ossy/hydrate-<pageId>.jsx`** → **`public/static/hydrate-<pageId>.js`**. The HTML for a request only loads the hydrate script for the **current** route (full document navigation), so other pages’ components are not part of that entry. React and shared dependencies still go into hashed shared chunks. The inline config (`window.__INITIAL_APP_CONFIG__`) no longer includes the full `pages` list—only request-time fields (theme, `apiUrl`, etc.).
 
@@ -51,7 +51,7 @@ Define HTTP handlers as an array of `{ id, path, handle(req, res) }` objects (sa
 
 Add any number of `*.api.js` (or `.api.mjs` / `.api.cjs`) files under `src/` (nested dirs allowed). Each file’s **default export** is either one route object or an array of routes. Files are merged in lexicographic path order.
 
-Build/dev always writes **`build/.ossy/api.generated.js`** (typically gitignored with `build/`). With no API files it exports an empty array.
+Build/dev writes **`build/.ossy/api.generated.json`** (discovered source paths) and **`api.bundle.json`** (Rollup outputs under **`api-modules/`**). The server imports **`api.runtime.mjs`**, which loads those modules. With no API files, both JSON files list empty arrays.
 
 Example `src/health.api.js`:
 
@@ -69,7 +69,7 @@ API routes are matched before the app is rendered. The router supports dynamic s
 
 ## Background worker tasks (`*.task.js`)
 
-For long-running job processors (separate from the SSR server), use **`npx @ossy/cli build --worker`** in a package that only needs the worker. It uses the same Rollup + Babel pipeline as `ossy build`, discovers **`*.task.js`** (and `.task.mjs` / `.task.cjs`) under `src/` (or `--pages <dir>`), and writes **`build/.ossy/tasks.generated.js`** when needed—same idea as `*.api.js` and the generated API bundle.
+For long-running job processors (separate from the SSR server), use **`npx @ossy/cli build --worker`** in a package that only needs the worker. It uses the same Rollup + Babel pipeline as `ossy build`, discovers **`*.task.js`** (and `.task.mjs` / `.task.cjs`) under `src/` (or `--pages <dir>`), and writes **`tasks.generated.json`** / **`tasks.bundle.json`** plus **`tasks.runtime.mjs`**—the same metadata + per-file compile pattern as API routes.
 
 Optional legacy aggregate: **`src/tasks.js`** default export is merged **first**, then each `*.task.js` in path order.
 

package/cli/api.runtime.mjs

@@ -0,0 +1,22 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const __ossyDir = path.dirname(fileURLToPath(import.meta.url))
+
+function normalizeApiExport (mod) {
+  const d = mod?.default
+  if (d == null) return []
+  return Array.isArray(d) ? d : [d]
+}
+
+const { modules } = JSON.parse(fs.readFileSync(path.join(__ossyDir, 'api.bundle.json'), 'utf8'))
+
+const out = []
+for (const rel of modules) {
+  const abs = path.resolve(__ossyDir, rel)
+  const mod = await import(pathToFileURL(abs).href)
+  out.push(...normalizeApiExport(mod))
+}
+
+export default out

package/cli/build-terminal.js

@@ -1,3 +1,5 @@
+import util from 'node:util'
+
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
 
 const dim = (s) => `\x1b[2m${s}\x1b[0m`
@@ -15,6 +17,13 @@ function padVisible (s, width) {
   return n >= width ? s : s + ' '.repeat(width - n)
 }
 
+function truncateVisible (s, maxW) {
+  const plain = stripAnsi(s)
+  if (plain.length <= maxW) return s
+  const cut = Math.max(0, maxW - 1)
+  return plain.slice(0, cut) + '…'
+}
+
 export function pageIdFromHydrateEntryName (entryName) {
   const p = String(entryName)
   return p.startsWith('hydrate__') ? p.slice('hydrate__'.length) : p
@@ -51,24 +60,35 @@ function rowLeadIcon (r, mode) {
   return green('✔')
 }
 
+function useTty (stream) {
+  return (
+    stream.isTTY === true &&
+    process.env.TERM !== 'dumb' &&
+    process.env.CI !== 'true' &&
+    process.env.OSSY_PLAIN_OUTPUT !== '1'
+  )
+}
+
 /**
- * Lerna-style live table: one row per page, hydrate + prerender columns.
- * TTY: redraws in place with a spinner while work runs. Non-TTY: one line per finished step.
+ * Merged overview + per-page progress, split layout: left = status table, right = log tail.
+ * TTY: single redraw block + optional console capture into the right column.
  */
-export function createParallelPagesReporter ({
+export function createBuildDashboard ({
   scope = '@ossy/app',
+  mode = 'full',
   pageIds,
+  /** @type {Record<string, string>} route path per page id */
+  idToPath = {},
+  overview = { title: '@ossy/app', configRel: null, apiRoutes: [] },
   stream = process.stdout,
-  /** `'full'`: hydrate + prerender columns. `'prerender-only'`: dev watch (client built separately). */
-  mode = 'full',
 } = {}) {
   const ids = [...pageIds].sort()
-  const maxId = Math.max(8, ...ids.map((id) => String(id).length))
-  const tty =
-    stream.isTTY === true &&
-    process.env.TERM !== 'dumb' &&
-    process.env.CI !== 'true' &&
-    process.env.OSSY_PLAIN_OUTPUT !== '1'
+  const maxId = Math.max(6, ...ids.map((id) => String(id).length))
+  const tty = useTty(stream)
+  const termW = Math.max(60, stream.columns || 100)
+  const LEFT_W = Math.min(56, Math.max(38, Math.floor(termW * 0.42)))
+  const GAP = 2
+  const RIGHT_W = Math.max(16, termW - LEFT_W - GAP)
 
   /** @type {Map<string, { bundle: object, prerender: object }>} */
   const rows = new Map()
@@ -79,9 +99,13 @@ export function createParallelPagesReporter ({
     })
   }
 
+  const logBuffer = []
+  const MAX_LOG = 120
   let frame = 0
   let spinTimer = null
   let blockLines = 0
+  let captureActive = false
+  let savedConsole = null
 
   const anyRunning = () => {
     for (const r of rows.values()) {
@@ -90,44 +114,107 @@ export function createParallelPagesReporter ({
     return false
   }
 
-  function ensureSpin () {
-    if (!tty || spinTimer) return
-    spinTimer = setInterval(() => {
-      frame += 1
-      redraw()
-    }, 80)
+  function pushLog (line) {
+    const s = String(line).trim() ? String(line) : ''
+    if (!s) return
+    if (!tty) {
+      stream.write(`${s}\n`)
+      return
+    }
+    logBuffer.push(dim(s))
+    if (logBuffer.length > MAX_LOG) logBuffer.splice(0, logBuffer.length - MAX_LOG)
+    redraw()
   }
 
-  function stopSpin () {
-    if (spinTimer) {
-      clearInterval(spinTimer)
-      spinTimer = null
+  function leftHeaderLines () {
+    const out = []
+    out.push(bold(overview.title || `${scope} build`))
+    if (overview.configRel) {
+      out.push(`${dim('config')}  ${truncateVisible(overview.configRel, LEFT_W - 10)}`)
     }
+    const api = overview.apiRoutes || []
+    if (api.length === 0) {
+      /* noop */
+    } else if (api.length <= 2) {
+      for (const r of api) {
+        const line = `${dim('api')}  ${truncateVisible(`${r.id}  ${r.path}`, LEFT_W - 6)}`
+        out.push(line)
+      }
+    } else {
+      out.push(`${dim('api')}  ${api.length} routes`)
+    }
+    out.push(dim('─'.repeat(Math.min(LEFT_W - 2, 44))))
+    return out
   }
 
-  function lineFor (id) {
+  function lineForPageRow (id) {
     const r = rows.get(id)
     const lead = rowLeadIcon(r, mode)
+    const pathStr = idToPath[id] != null ? dim(String(idToPath[id])) : ''
     const idCol = padVisible(dim(String(id)), maxId)
+    const pathPad = padVisible(pathStr, 14)
     const p = fmtPart(r.prerender, 'html', frame)
     if (mode === 'prerender-only') {
-      return `  ${lead} ${dim(scope)}  ${idCol}  ${p}`
+      return `  ${lead} ${dim(scope)}  ${idCol}  ${pathPad}  ${p}`
     }
     const b = fmtPart(r.bundle, 'hydrate', frame)
-    return `  ${lead} ${dim(scope)}  ${idCol}  ${padVisible(b, 24)}  ${p}`
+    return `  ${lead} ${dim(scope)}  ${idCol}  ${pathPad}  ${padVisible(b, 20)}  ${p}`
+  }
+
+  function buildLeftColumnLines () {
+    const head = leftHeaderLines()
+    const body = ids.map((id) => lineForPageRow(id))
+    return [...head, ...body]
+  }
+
+  function buildHeaderOnlyLines () {
+    return leftHeaderLines()
+  }
+
+  /** Right column row i: logs bottom-aligned to the block height */
+  function rightColumnLine (i, totalRows) {
+    const start = logBuffer.length - totalRows + i
+    if (start < 0 || start >= logBuffer.length) return dim('·')
+    return truncateVisible(logBuffer[start], RIGHT_W)
+  }
+
+  function paintRow (leftLine, rightLine) {
+    const L = padVisible(truncateVisible(leftLine, LEFT_W), LEFT_W)
+    const R = truncateVisible(rightLine, RIGHT_W)
+    return `${L}${' '.repeat(GAP)}${R}\n`
   }
 
   function redraw () {
     if (!tty) return
-    const lines = ids.map((id) => lineFor(id))
+    const leftCol = buildLeftColumnLines()
+    const n = leftCol.length
+    const lines = []
+    for (let i = 0; i < n; i++) {
+      lines.push(paintRow(leftCol[i], rightColumnLine(i, n)))
+    }
     if (blockLines === 0) {
-      for (const ln of lines) stream.write(`${ln}\n`)
+      for (const ln of lines) stream.write(ln)
       blockLines = lines.length
       return
     }
     stream.write(`\x1b[${blockLines}A`)
     for (const ln of lines) {
-      stream.write(`\x1b[2K\r${ln}\n`)
+      stream.write(`\x1b[2K\r${ln}`)
+    }
+  }
+
+  function ensureSpin () {
+    if (!tty || spinTimer) return
+    spinTimer = setInterval(() => {
+      frame += 1
+      redraw()
+    }, 80)
+  }
+
+  function stopSpin () {
+    if (spinTimer) {
+      clearInterval(spinTimer)
+      spinTimer = null
     }
   }
 
@@ -139,7 +226,58 @@ export function createParallelPagesReporter ({
     if (err && !ok) stream.write(`    ${red(String(err.message || err))}\n`)
   }
 
+  function beginCapture () {
+    if (!tty || captureActive) return
+    captureActive = true
+    savedConsole = {
+      log: console.log,
+      warn: console.warn,
+      info: console.info,
+      error: console.error,
+    }
+    const fmt = (...a) => util.format(...a)
+    console.log = (...a) => {
+      pushLog(`[log] ${fmt(...a)}`)
+    }
+    console.warn = (...a) => {
+      pushLog(`[warn] ${fmt(...a)}`)
+    }
+    console.info = (...a) => {
+      pushLog(`[info] ${fmt(...a)}`)
+    }
+    console.error = (...a) => {
+      const msg = fmt(...a)
+      pushLog(`[error] ${msg}`)
+      savedConsole.error(`[@ossy/app] ${msg}`)
+    }
+  }
+
+  function endCapture () {
+    if (!captureActive || !savedConsole) return
+    console.log = savedConsole.log
+    console.warn = savedConsole.warn
+    console.info = savedConsole.info
+    console.error = savedConsole.error
+    savedConsole = null
+    captureActive = false
+  }
+
   return {
+    pushLog,
+
+    /** Start optional console hijack + first paint (TTY). Plain header only when not a TTY. */
+    start () {
+      if (!tty) {
+        for (const ln of buildHeaderOnlyLines()) {
+          stream.write(`${ln}\n`)
+        }
+        stream.write('\n')
+        return
+      }
+      beginCapture()
+      redraw()
+    },
+
     startBundle (pageId) {
       if (mode === 'prerender-only') return
       const r = rows.get(pageId)
@@ -188,23 +326,18 @@ export function createParallelPagesReporter ({
       redraw()
     },
 
-    /** Stop spinner and leave cursor below the block (TTY). */
-    dispose () {
-      stopSpin()
-      if (tty && blockLines > 0) {
-        redraw()
-        stream.write('\n')
-        blockLines = 0
-      }
+    printSectionTitle () {
+      /* merged into overview.title — no-op for API compat */
     },
 
-    printSectionTitle (title) {
+    dispose () {
       stopSpin()
+      endCapture()
       if (tty && blockLines > 0) {
+        redraw()
         stream.write('\n')
         blockLines = 0
       }
-      stream.write(`\n  ${bold(scope)}  ${dim(title)}\n`)
     },
   }
 }