@mnstry/atelier 0.2.0-alpha.4 → 0.2.0-alpha.5

package/src/server/local-sidecar.mjs

@@ -5,9 +5,17 @@ import fs from 'node:fs'
 import http from 'node:http'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import {
+  atomicReplacePrivateText,
+  ensureContainedPrivateDirectory,
+  readRegularTextNoFollow,
+} from '../project/private-state.mjs'
 import {
   expectedOriginForRequest,
   htmlDocumentHeaders,
+  isLoopbackHost,
+  loadPublishedWorkspaceManifest,
+  publishedStaticPathVerdict,
   requestHeader,
   resolveWorkspacePath,
   staticHeaders,
@@ -43,39 +51,37 @@ function nowMs() {
 
 function readJsonFile(file, fallback) {
   try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'))
+    return JSON.parse(readRegularTextNoFollow(file))
   } catch {
     return fallback
   }
 }
 
 function secureWriteJson(file, payload, mode = 0o600) {
-  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`
-  fs.writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}\n`, { mode })
-  fs.renameSync(tmp, file)
-  try {
-    fs.chmodSync(file, mode)
-  } catch {
-    // Best effort on filesystems that do not support chmod.
-  }
+  atomicReplacePrivateText(file, `${JSON.stringify(payload, null, 2)}\n`, mode)
 }
 
 function readOrCreateNonce(noncePath) {
-  const existing = fs.existsSync(noncePath) ? fs.readFileSync(noncePath, 'utf8').trim() : ''
+  let existing = ''
+  if (fs.existsSync(noncePath)) {
+    const stat = fs.lstatSync(noncePath)
+    if (!stat.isFile()) throw new Error('nonce state leaf is not a regular file')
+    existing = readRegularTextNoFollow(noncePath).trim()
+  }
   if (/^[a-f0-9]{64}$/.test(existing)) return existing
   const nonce = crypto.randomBytes(32).toString('hex')
-  fs.writeFileSync(noncePath, `${nonce}\n`, { mode: 0o600 })
+  atomicReplacePrivateText(noncePath, `${nonce}\n`)
   return nonce
 }
 
-function json(res, code, obj) {
+function json(res, code, obj, headers = {}) {
   const body = Buffer.from(`${JSON.stringify(obj, null, 2)}\n`)
   res.writeHead(code, {
     'Content-Type': 'application/json; charset=utf-8',
     'Content-Length': String(body.length),
     'Cache-Control': 'no-store',
     'X-Content-Type-Options': 'nosniff',
+    ...headers,
   })
   res.end(body)
 }
@@ -205,16 +211,33 @@ export function createAtelierSidecarServer({
 } = {}) {
   const root = path.resolve(workspaceRoot)
   const rootReal = fs.realpathSync(root)
+  const stateDirReal = ensureContainedPrivateDirectory({
+    workspaceRoot: root,
+    directory: stateDir,
+    label: 'Atelier state directory',
+  })
+  const publication = loadPublishedWorkspaceManifest(root)
   const workspaceId = workspaceIdForRoot(root)
-  const noncePath = path.join(stateDir, '.atelier-nonce')
-  const presencePath = path.join(stateDir, '.atelier-presence.json')
+  const noncePath = path.join(stateDirReal, '.atelier-nonce')
+  const presencePath = path.join(stateDirReal, '.atelier-presence.json')
   const mutationNonce = readOrCreateNonce(noncePath)
   const proposals = createProposalStore({
     workspaceRoot: root,
-    proposalsDir: path.join(stateDir, '.atelier-proposals'),
+    proposalsDir: path.join(stateDirReal, '.atelier-proposals'),
     workspaceId,
   })
 
+  function resolvePublishedPath({ rel, requireFile = false, requireHtml = false } = {}) {
+    const resolved = resolveWorkspacePath({
+      workspaceRoot: root,
+      workspaceRootReal: rootReal,
+      rel,
+      requireFile,
+      requireHtml,
+    })
+    return publishedStaticPathVerdict({ resolved, publication })
+  }
+
   function readPresence() {
     const presence = readJsonFile(presencePath, defaultPresence())
     return {
@@ -229,12 +252,7 @@ export function createAtelierSidecarServer({
   }
 
   function recordView(rel, hints = {}) {
-    const resolved = resolveWorkspacePath({
-      workspaceRoot: root,
-      workspaceRootReal: rootReal,
-      rel,
-      requireHtml: true,
-    })
+    const resolved = resolvePublishedPath({ rel, requireHtml: true })
     if (!resolved.ok) return { ok: false, error: 'unknown workspace html file' }
     const entry = {
       sessionId: cleanIdentity(hints.sessionId, 120),
@@ -295,12 +313,7 @@ export function createAtelierSidecarServer({
     const viewId = cleanIdentity(url.searchParams.get('viewId'), 120)
     const rel = cleanIdentity(url.searchParams.get('path') || 'index.html', 500)
     const expectedWorkspaceId = cleanIdentity(url.searchParams.get('expectedWorkspaceId'), 120)
-    const resolved = resolveWorkspacePath({
-      workspaceRoot: root,
-      workspaceRootReal: rootReal,
-      rel,
-      requireHtml: true,
-    })
+    const resolved = resolvePublishedPath({ rel, requireHtml: true })
     const current = resolveCurrentContext({ sessionId })
     const workspaceVerified = Boolean(expectedWorkspaceId && expectedWorkspaceId === workspaceId)
     const caps = capabilityContract()
@@ -366,12 +379,7 @@ export function createAtelierSidecarServer({
     }
 
     if (url.pathname === '/api/proposals') {
-      const resolved = resolveWorkspacePath({
-        workspaceRoot: root,
-        workspaceRootReal: rootReal,
-        rel: body.path || body.rel,
-        requireHtml: true,
-      })
+      const resolved = resolvePublishedPath({ rel: body.path || body.rel, requireHtml: true })
       if (!resolved.ok) {
         json(res, 200, { ok: false, error: 'unknown workspace html file' })
         return
@@ -392,6 +400,7 @@ export function createAtelierSidecarServer({
         schema: result.record.schema,
         workspaceId,
         proposal: result.record.proposal,
+        diagnostics: result.diagnostics,
       })
       return
     }
@@ -416,6 +425,7 @@ export function createAtelierSidecarServer({
         proposal: result.record.proposal,
         diff: result.record.diff,
         copyable: result.record.copyable,
+        diagnostics: result.diagnostics,
       })
       return
     }
@@ -430,12 +440,7 @@ export function createAtelierSidecarServer({
     }
 
     const rel = url.pathname === '/' ? 'index.html' : url.pathname.slice(1)
-    const resolved = resolveWorkspacePath({
-      workspaceRoot: root,
-      workspaceRootReal: rootReal,
-      rel,
-      requireFile: true,
-    })
+    const resolved = resolvePublishedPath({ rel, requireFile: true })
     if (!resolved.ok) {
       text(res, resolved.status || 403, `${resolved.error || 'forbidden'}\n`)
       return
@@ -463,6 +468,16 @@ export function createAtelierSidecarServer({
       return
     }
 
+    if (!['GET', 'HEAD', 'POST'].includes(req.method || '')) {
+      json(res, 405, { ok: false, error: 'method not allowed' }, { Allow: 'GET, HEAD, POST' })
+      return
+    }
+
+    if (!trustedReadRequest(req.headers, { expectedOrigin })) {
+      json(res, 403, { ok: false, error: 'cross-origin or unclassified request refused' })
+      return
+    }
+
     if (req.method === 'POST') {
       await handlePost(req, res, url)
       return
@@ -478,12 +493,7 @@ export function createAtelierSidecarServer({
         return
       }
       const rel = url.searchParams.get('path') || 'index.html'
-      const resolved = resolveWorkspacePath({
-        workspaceRoot: root,
-        workspaceRootReal: rootReal,
-        rel,
-        requireHtml: true,
-      })
+      const resolved = resolvePublishedPath({ rel, requireHtml: true })
       if (!resolved.ok) {
         json(res, 404, { ok: false, error: 'unknown workspace html file' })
         return
@@ -509,12 +519,7 @@ export function createAtelierSidecarServer({
       return
     }
     if (url.pathname === '/api/resolve') {
-      const resolved = resolveWorkspacePath({
-        workspaceRoot: root,
-        workspaceRootReal: rootReal,
-        rel: url.searchParams.get('path') || 'index.html',
-        requireHtml: true,
-      })
+      const resolved = resolvePublishedPath({ rel: url.searchParams.get('path') || 'index.html', requireHtml: true })
       json(res, resolved.ok ? 200 : (resolved.status || 404), {
         ok: resolved.ok,
         schema: ATELIER_RESOLVE_SCHEMA,
@@ -533,37 +538,49 @@ export function createAtelierSidecarServer({
       return
     }
     if (url.pathname === '/api/proposals') {
+      const listed = proposals.listProposals()
+      if (!listed.ok) {
+        json(res, listed.status, { ok: false, error: listed.error, diagnostics: listed.diagnostics })
+        return
+      }
       json(res, 200, {
         ok: true,
         schema: 'atelier-proposals@v1',
         workspaceId,
-        proposals: proposals.listProposals(),
+        proposals: listed.proposals,
       })
       return
     }
     const proposalReadMatch = url.pathname.match(/^\/api\/proposals\/([^/]+)$/)
     if (proposalReadMatch) {
-      const record = proposals.readProposal(proposalReadMatch[1])
-      json(res, record ? 200 : 404, record ? {
+      const result = proposals.readProposal(proposalReadMatch[1])
+      const record = result.record
+      json(res, result.ok ? 200 : result.status, result.ok ? {
         ok: true,
         schema: record.schema,
         workspaceId,
         proposal: record.proposal,
         diff: record.diff,
         copyable: record.copyable,
-      } : { ok: false, error: 'proposal not found' })
+      } : { ok: false, error: result.error, diagnostics: result.diagnostics })
       return
     }
     if (url.pathname === '/proposals') {
-      const body = renderProposalListPageHtml(proposals.listProposals())
+      const listed = proposals.listProposals()
+      if (!listed.ok) {
+        text(res, listed.status, `${listed.error}\n`)
+        return
+      }
+      const body = renderProposalListPageHtml(listed.proposals)
       res.writeHead(200, htmlDocumentHeaders(Buffer.byteLength(body)))
       res.end(body)
       return
     }
     const proposalPageMatch = url.pathname.match(/^\/proposals\/([^/]+)$/)
     if (proposalPageMatch) {
-      const body = renderProposalDetailPageHtml(proposals.readProposal(proposalPageMatch[1]))
-      res.writeHead(200, htmlDocumentHeaders(Buffer.byteLength(body)))
+      const result = proposals.readProposal(proposalPageMatch[1])
+      const body = renderProposalDetailPageHtml(result.record)
+      res.writeHead(result.ok ? 200 : result.status, htmlDocumentHeaders(Buffer.byteLength(body)))
       res.end(body)
       return
     }
@@ -595,8 +612,12 @@ export function createAtelierSidecarServer({
     workspaceRootReal: rootReal,
     workspaceId,
     mutationNonce,
+    publication,
     proposals,
     listen(listenPort = port, host = '127.0.0.1') {
+      if (!isLoopbackHost(host)) {
+        return Promise.reject(new Error(`non-loopback listen host refused: ${host}`))
+      }
       // A busy port is an ordinary condition, not a crash: surface it as a
       // rejection the CLI can print, instead of an unhandled 'error' event.
       return new Promise((resolve, reject) => {
@@ -615,6 +636,7 @@ export function createAtelierSidecarServer({
       })
     },
     close() {
+      if (!server.listening) return Promise.resolve()
       return new Promise((resolve, reject) => {
         server.close((error) => {
           if (error) reject(error)

package/src/server/security.mjs

@@ -37,6 +37,9 @@ export const LOOPBACK_HOSTS = new Set([
   '[::1]',
 ])
 
+export const ATELIER_MANIFEST_SCHEMA = 'mnstry.atelier-manifest@v1'
+export const PUBLISHED_STATIC_EXTENSIONS = new Set(['.html', '.js', '.mjs', '.css', '.svg', '.png', '.jpg', '.jpeg', '.webp'])
+
 export function parseHostHeader(value) {
   const raw = String(value || '').trim().toLowerCase()
   if (!raw) return ''
@@ -66,7 +69,7 @@ export function expectedOriginForRequest(headers, fallbackPort = null) {
 }
 
 export function sameOrigin(origin, expectedOrigin) {
-  if (!origin) return true
+  if (!origin) return false
   if (!expectedOrigin) return false
   try {
     return new URL(origin).origin === new URL(expectedOrigin).origin
@@ -77,7 +80,7 @@ export function sameOrigin(origin, expectedOrigin) {
 
 export function trustedFetchSite(headers) {
   const value = requestHeader(headers, 'sec-fetch-site').toLowerCase()
-  return value === '' || value === 'none' || value === 'same-origin' || value === 'same-site'
+  return value === 'none' || value === 'same-origin'
 }
 
 export function trustedHost(headers) {
@@ -85,11 +88,92 @@ export function trustedHost(headers) {
 }
 
 export function trustedReadRequest(headers, { expectedOrigin = expectedOriginForRequest(headers) } = {}) {
-  return trustedHost(headers) && sameOrigin(requestHeader(headers, 'origin'), expectedOrigin)
+  const origin = requestHeader(headers, 'origin')
+  return trustedHost(headers) && trustedFetchSite(headers) && (!origin || sameOrigin(origin, expectedOrigin))
 }
 
 export function trustedMutationRequest(headers, { expectedOrigin = expectedOriginForRequest(headers) } = {}) {
-  return trustedReadRequest(headers, { expectedOrigin }) && trustedFetchSite(headers)
+  const origin = requestHeader(headers, 'origin')
+  return Boolean(origin) && trustedReadRequest(headers, { expectedOrigin }) && sameOrigin(origin, expectedOrigin)
+}
+
+function manifestPathValue(value) {
+  if (typeof value === 'string') return value
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return ''
+  return value.path || value.output || value.href || ''
+}
+
+function secretShapedPath(value) {
+  return /(?:^|[._-])(?:secret|credential|token|password|nonce|private[._-]?key)(?:$|[._-])/i.test(value)
+    || /(?:^|\/)\.env(?:\.|$)/i.test(value)
+}
+
+function addManifestPath(paths, value, label) {
+  const candidate = manifestPathValue(value)
+  const normalized = normalizeWorkspacePath(candidate, { defaultFile: '' })
+  if (!candidate || !normalized.ok || /^[a-z][a-z0-9+.-]*:/i.test(candidate)) {
+    throw new Error(`atelier.manifest.json ${label} must be a workspace-relative path`)
+  }
+  if (deniedStaticStatePath(normalized.path) || normalized.path.split('/').some((segment) => segment.startsWith('.')) || secretShapedPath(normalized.path)) {
+    throw new Error(`atelier.manifest.json ${label} enrolls a hidden, state, or secret-shaped path`)
+  }
+  if (!PUBLISHED_STATIC_EXTENSIONS.has(path.extname(normalized.path).toLowerCase())) {
+    throw new Error(`atelier.manifest.json ${label} enrolls an unsupported static file type`)
+  }
+  paths.add(normalized.path)
+}
+
+export function loadPublishedWorkspaceManifest(workspaceRoot) {
+  const root = path.resolve(workspaceRoot)
+  const rootReal = fs.realpathSync(root)
+  const manifestPath = path.join(root, 'atelier.manifest.json')
+  if (!fs.existsSync(manifestPath)) throw new Error('served workspace must contain generated atelier.manifest.json')
+  const manifestReal = fs.realpathSync(manifestPath)
+  if (!pathContainedBy(rootReal, manifestReal)) throw new Error('atelier.manifest.json realpath escapes served workspace')
+  let manifest
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestReal, 'utf8'))
+  } catch (error) {
+    throw new Error(`atelier.manifest.json must be valid JSON: ${error.message}`)
+  }
+  if (manifest?.schema !== ATELIER_MANIFEST_SCHEMA) {
+    throw new Error(`atelier.manifest.json schema must be ${ATELIER_MANIFEST_SCHEMA}`)
+  }
+  const paths = new Set()
+  if (typeof manifest.entry !== 'string') throw new Error('atelier.manifest.json entry must be a workspace-relative HTML path')
+  addManifestPath(paths, manifest.entry, 'entry')
+  if (path.extname(manifest.entry).toLowerCase() !== '.html') throw new Error('atelier.manifest.json entry must be an HTML file')
+  for (const key of ['files', 'assets']) {
+    if (manifest[key] == null) continue
+    if (!Array.isArray(manifest[key])) throw new Error(`atelier.manifest.json ${key} must be an array`)
+    for (const [index, value] of manifest[key].entries()) addManifestPath(paths, value, `${key}[${index}]`)
+  }
+  for (const rel of paths) {
+    const resolved = resolveWorkspacePath({ workspaceRoot: root, workspaceRootReal: rootReal, rel, requireFile: true })
+    if (!resolved.ok) throw new Error(`atelier.manifest.json enrolled path is unavailable: ${rel}`)
+    const realRel = path.relative(rootReal, resolved.real).replaceAll('\\', '/')
+    if (realRel !== rel) throw new Error(`atelier.manifest.json enrolled path must not be a symlink: ${rel}`)
+  }
+  return Object.freeze({ manifest, manifestPath: manifestReal, paths })
+}
+
+export function publishedStaticPathVerdict({ resolved, publication } = {}) {
+  if (!resolved?.ok) return resolved
+  const realRel = path.relative(resolved.workspaceRootReal, resolved.real).replaceAll('\\', '/')
+  const segments = realRel.split('/')
+  if (segments.some((segment) => segment.startsWith('.')) || deniedStaticStatePath(realRel)) {
+    return { ok: false, status: 403, error: 'hidden or local state path is not published', path: resolved.path }
+  }
+  if (realRel === 'atelier.manifest.json' || secretShapedPath(realRel)) {
+    return { ok: false, status: 403, error: 'secret-shaped path is not published', path: resolved.path }
+  }
+  if (!PUBLISHED_STATIC_EXTENSIONS.has(path.extname(realRel).toLowerCase())) {
+    return { ok: false, status: 403, error: 'static file type is not published', path: resolved.path }
+  }
+  if (!publication?.paths?.has(realRel)) {
+    return { ok: false, status: 404, error: 'path is not enrolled by atelier.manifest.json', path: resolved.path }
+  }
+  return resolved
 }
 
 export function pathContainedBy(root, candidate) {
@@ -191,6 +275,7 @@ export function resolveWorkspacePath({
     real,
     stat,
     workspaceContained: true,
+    workspaceRootReal,
   }
 }
 

package/src/server/server.mjs

@@ -26,11 +26,12 @@ export async function runServerCommand(argv = process.argv.slice(2)) {
   if (args.smoke) {
     const address = await sidecar.listen()
     const base = `http://127.0.0.1:${address.port}`
+    const headers = { Origin: base, 'Sec-Fetch-Site': 'same-origin' }
     // @atelier-egress-local-computed
-    const health = await fetch(`${base}/api/health`).then((res) => res.json())
+    const health = await fetch(`${base}/api/health`, { headers }).then((res) => res.json())
     if (!health.ok) throw new Error('health check failed')
     // @atelier-egress-local-computed
-    const page = await fetch(`${base}/index.html`).then((res) => res.text())
+    const page = await fetch(`${base}/`, { headers }).then((res) => res.text())
     if (!page.includes('<meta name="mnstry:atelier"')) throw new Error('projection smoke failed')
     await sidecar.close()
     console.log('[atelier:browser:smoke] local projection and health endpoint passed')

package/src/support/feedback-report.mjs

@@ -56,7 +56,7 @@ const USAGE = `Usage: atelier feedback <subcommand>
 Subcommands:
   create --message TEXT | --message-file PATH [--context FILE] [--include-gates]
       Assemble a local feedback report from your own words and write it to
-      ${LOCAL_STATE_DIR}/feedback/<hash>.json (mode 0600). This is the
+      ${LOCAL_STATE_DIR}/feedback/<hash>.json (mode 0600 on POSIX). This is the
       default subcommand. The report is first walked with the support-bundle
       banned key and value patterns; if anything matches, nothing is written
       and the refusal names the pattern label and location only.
@@ -202,8 +202,9 @@ export function buildFeedbackReport({
 }
 
 export function writeFeedbackReport(payload, { baseDir = process.cwd() } = {}) {
-  const relative = path.join(LOCAL_STATE_DIR, 'feedback', `${feedbackReportHash(payload)}.json`)
-  const file = path.join(baseDir, relative)
+  const nativeRelative = path.join(LOCAL_STATE_DIR, 'feedback', `${feedbackReportHash(payload)}.json`)
+  const relative = nativeRelative.split(path.sep).join('/')
+  const file = path.join(baseDir, nativeRelative)
   // "Local state" is only local if the directory it lands in is ignored, and
   // feedback writes wherever the user happens to stand rather than in a
   // configured workspace. Same git check-ignore test the project chassis runs

package/src/upgrade/upgrade.mjs

@@ -14,6 +14,7 @@ import {
   resolvePathValue,
   writeJson,
 } from '../project/config.mjs'
+import { packageRootFrom } from '../project/package-root.mjs'
 import {
   BOUNDARY_POLICY_SCHEMA,
   checkBoundaryPolicy,
@@ -36,7 +37,7 @@ export const MIGRATION_CLASSES = new Set([
   'breaking',
 ])
 
-const packageRoot = path.resolve(new URL('../..', import.meta.url).pathname)
+const packageRoot = packageRootFrom(import.meta.url)
 const packageJson = readJson(path.join(packageRoot, 'package.json'))
 const lockSchema = readJson(path.join(packageRoot, 'contracts', 'atelier-lock.v1.schema.json'))
 const REVIEW_MARKER_RE = /(Atelier-Boundary-Review|boundary-review)\s*:\s*(approved|reviewed)/i