@mnstry/atelier 0.2.0-alpha.6 → 0.2.0-alpha.8

package/src/runtime/obsidian/tick-loop.mjs

@@ -0,0 +1,84 @@
+// Calls one `tick` again and again, never two at a time.
+//
+// The next tick is scheduled only when the previous one has settled, so ticks
+// cannot overlap however long one takes. A tick that throws does not end the
+// loop and does not change the next tick: the error is handed to `onOutcome`,
+// and the delay before the next attempt doubles per consecutive failure up to
+// a ceiling, so a disk that stays full is retried slowly instead of in a tight
+// loop. One success returns the loop to its interval.
+//
+// `tickNow()` asks for a tick that starts after the request: while a tick is
+// in flight the request is answered by one follow-up tick, shared by everyone
+// who asked meanwhile.
+
+export const DEFAULT_TICK_INTERVAL_MS = 30 * 1000
+export const DEFAULT_MAX_BACKOFF_MS = 15 * 60 * 1000
+
+export const TICK_LOOP_PRIMITIVES = Object.freeze({
+  // Whether the loop goes on after a tick threw.
+  continuesAfterError: () => true,
+  delayAfter: ({ intervalMs, maxBackoffMs, consecutiveFailures }) => (consecutiveFailures === 0 ? intervalMs : Math.min(maxBackoffMs, intervalMs * 2 ** Math.min(consecutiveFailures, 20))),
+})
+
+export function createTickLoopForOracleTests({ tick, intervalMs = DEFAULT_TICK_INTERVAL_MS, maxBackoffMs = DEFAULT_MAX_BACKOFF_MS, setTimer = setTimeout, clearTimer = clearTimeout, onOutcome = () => {} }, primitives = TICK_LOOP_PRIMITIVES) {
+  if (typeof tick !== 'function') throw new TypeError('the tick loop needs a tick')
+  if (!Number.isInteger(intervalMs) || intervalMs < 1 || !Number.isInteger(maxBackoffMs) || maxBackoffMs < intervalMs) throw new TypeError('the tick loop needs a positive interval and a backoff ceiling no smaller than it')
+  const rules = { ...TICK_LOOP_PRIMITIVES, ...primitives }
+  let timer = null
+  let inFlight = null
+  let followUp = null // { promise, resolve } while somebody waits for a tick that starts after now
+  let started = false
+  let stopped = false
+  let consecutiveFailures = 0
+  let ticks = 0
+
+  function schedule() {
+    if (stopped || !started || timer !== null) return
+    timer = setTimer(() => { timer = null; void run() }, rules.delayAfter({ intervalMs, maxBackoffMs, consecutiveFailures }))
+  }
+
+  async function once() {
+    let outcome
+    try { outcome = { ok: true, report: await tick() } } catch (error) { outcome = { ok: false, error } }
+    ticks += 1
+    consecutiveFailures = outcome.ok ? 0 : consecutiveFailures + 1
+    try { await onOutcome({ ...outcome, consecutiveFailures }) } catch { /* recording an outcome never ends the loop */ }
+    if (!outcome.ok && !rules.continuesAfterError()) stopped = true
+    return outcome
+  }
+
+  function run() {
+    if (stopped) return Promise.resolve({ ok: false, stopped: true })
+    if (inFlight) return inFlight
+    if (timer !== null) { clearTimer(timer); timer = null }
+    inFlight = once().finally(() => {
+      inFlight = null
+      const waiting = followUp
+      followUp = null
+      if (waiting) run().then(waiting.resolve)
+      else schedule()
+    })
+    return inFlight
+  }
+
+  return {
+    start() { if (!started && !stopped) { started = true; void run() } },
+    tickNow() {
+      if (stopped) return Promise.resolve({ ok: false, stopped: true })
+      if (!inFlight) return run()
+      if (!followUp) { let resolve; const promise = new Promise((settle) => { resolve = settle }); followUp = { promise, resolve } }
+      return followUp.promise
+    },
+    // Lets the tick in flight finish; starts no other.
+    async stop() {
+      stopped = true
+      if (timer !== null) { clearTimer(timer); timer = null }
+      if (inFlight) await inFlight.catch(() => {})
+    },
+    state: () => ({ started, stopped, ticking: inFlight !== null, ticks, consecutiveFailures, nextDelayMs: rules.delayAfter({ intervalMs, maxBackoffMs, consecutiveFailures }) }),
+  }
+}
+
+export function createTickLoop(options) {
+  return createTickLoopForOracleTests(options, TICK_LOOP_PRIMITIVES)
+}

package/src/runtime/obsidian/watchers.mjs

@@ -0,0 +1,36 @@
+import fs from 'node:fs'
+
+// Filesystem watchers, as hints only.
+//
+//   factory({ roots: [{ id, path, recursive }], onEvent }) -> { close() }
+//   onEvent({ rootId, relative })   relative is a '/'-separated path under the
+//                                   root, or null for "something under it"
+//
+// A watcher may drop, repeat or delay events and may fail to start at all; the
+// engine never depends on one. It only hashes a named file sooner than the
+// next stat scan would have. Tests inject a factory they drive by hand.
+
+export function createNullWatcherFactory() {
+  return () => ({ close() {} })
+}
+
+// fs.watch, recursive where the platform supports it. It does not keep the
+// process alive, and a root that cannot be watched is reported, not thrown:
+// digest reconciliation still covers it.
+export function createFsWatcherFactory({ watch = fs.watch, onUnavailable = () => {} } = {}) {
+  return ({ roots, onEvent }) => {
+    const watchers = []
+    for (const root of roots) {
+      try {
+        const watcher = watch(root.path, { recursive: root.recursive !== false, persistent: false }, (_eventType, filename) => {
+          onEvent({ rootId: root.id, relative: typeof filename === 'string' && filename !== '' ? filename.split('\\').join('/') : null })
+        })
+        watcher.on('error', () => onUnavailable({ rootId: root.id }))
+        watchers.push(watcher)
+      } catch {
+        onUnavailable({ rootId: root.id })
+      }
+    }
+    return { close() { for (const watcher of watchers.splice(0)) try { watcher.close() } catch { /* already closed */ } } }
+  }
+}

package/src/runtime/supervisor.mjs

@@ -2,7 +2,7 @@ import crypto from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
 import { checkBoundaryPolicy, loadBoundaryPolicy } from '../boundary/policy.mjs'
-import { commandProject } from '../project/config.mjs'
+import { commandProject, resolveProjectConfig } from '../project/config.mjs'
 import { classifyRemoteAuthentication, inspectGitEngine, redactGitDiagnostic, resolveGitExecutable, runGit, sanitizeRemoteUrl } from './git-adapter.mjs'
 import {
   ATELIER_RUNTIME_ENROLLMENT_SCHEMA,
@@ -23,6 +23,7 @@ import {
   writeRuntimeState,
 } from './local-state.mjs'
 import { observeRepository, resolveRepositoryRoot } from './repository-observation.mjs'
+import { maintenanceNoticeFor } from './obsidian/sync-notice.mjs'
 
 export const ATELIER_COMMIT_PLAN_SCHEMA = 'atelier-commit-plan@v1'
 
@@ -786,3 +787,17 @@ export function operationTrace({ repoPath = process.cwd() } = {}) {
   const { paths } = loadEnrollment(repoPath)
   return readOperationTrace(paths.trace)
 }
+
+// Report only. Git synchronization cannot maintain an external Obsidian vault and does not try: when the enrolled
+// project enables that integration, `sync` repeats what maintenance last persisted and points at its own command.
+// Null when the project is not configured for it or has it off, and then the output of `sync` is unchanged.
+export function obsidianMaintenanceNotice({ repoPath = process.cwd(), env = process.env } = {}) {
+  try {
+    const { enrollment } = loadEnrollment(repoPath, { env })
+    if (!enrollment.projectConfig) return null
+    return maintenanceNoticeFor(resolveProjectConfig({ argv: [`--project=${enrollment.projectConfig}`], cwd: enrollment.repoRoot, env, writeLocalState: false }), { env })
+  } catch {
+    // A report must never change what sync does or whether it succeeds.
+    return null
+  }
+}

package/src/server/local-sidecar.mjs

@@ -30,6 +30,10 @@ import {
   renderProposalListPageHtml,
 } from '../ui/html-primitives.mjs'
 
+import { createReviewStore } from '../collaboration/review-store.mjs'
+import { loadBoundRun, currentRunEligibility } from '../readiness-protocols/evidence.mjs'
+import { renderReviewPage } from '../ui/review-page.mjs'
+
 export const ATELIER_CONTEXT_SCHEMA = 'atelier-context@v1'
 export const ATELIER_PRESENCE_SCHEMA = 'atelier-presence@v1'
 export const ATELIER_RESOLVE_SCHEMA = 'atelier-resolve@v1'
@@ -206,6 +210,7 @@ function doctorEnvelope() {
 export function createAtelierSidecarServer({
   workspaceRoot = process.cwd(),
   stateDir = workspaceRoot,
+  reviewProject = null,
   port = 0,
   presenceTtlMs = Number(process.env.ATELIER_PRESENCE_TTL_MS || 5 * 60 * 1000),
 } = {}) {
@@ -217,6 +222,7 @@ export function createAtelierSidecarServer({
     label: 'Atelier state directory',
   })
   const publication = loadPublishedWorkspaceManifest(root)
+  const review = reviewProject ? createReviewStore(reviewProject) : null
   const workspaceId = workspaceIdForRoot(root)
   const noncePath = path.join(stateDirReal, '.atelier-nonce')
   const presencePath = path.join(stateDirReal, '.atelier-presence.json')
@@ -366,12 +372,31 @@ export function createAtelierSidecarServer({
       json(res, 400, { ok: false, error: error.message })
       return
     }
+    // Browsers send Origin on POST; same-origin GET normally omits it. Keep
+    // the strict origin gate for nonce disclosure instead of relaxing the
+    // existing session-auth GET contract or accepting unclassified reads.
+    if (review && url.pathname === '/api/review/session') {
+      if (!trustedMutationRequest(req.headers) || !body || Array.isArray(body) || Object.keys(body).length) {
+        json(res, 403, { ok: false, error: 'review session requires a same-origin empty request' })
+        return
+      }
+      const published = resolvePublishedPath({ rel: 'index.html', requireHtml: true })
+      if (!published.ok) { json(res, 404, { ok: false, error: 'published workspace unavailable' }); return }
+      json(res, 200, { ok: true, schema: ATELIER_SESSION_AUTH_SCHEMA, workspaceId, mutationNonce })
+      return
+    }
     const auth = requireMutationAuth(req, body, mutationNonce)
     if (!auth.ok) {
       json(res, auth.status, { ok: false, error: auth.error })
       return
     }
 
+    if (review && url.pathname === '/api/review/contributions') {
+      const result = review.contribute(body)
+      json(res, result.status, result)
+      return
+    }
+
     if (url.pathname === '/api/seen') {
       const result = recordView(body.rel || body.path, body)
       json(res, 200, result.ok ? { ok: true, entry: result.entry } : result)
@@ -483,6 +508,25 @@ export function createAtelierSidecarServer({
       return
     }
 
+    if (review && url.pathname === '/review') {
+      const body = renderReviewPage()
+      res.writeHead(200, htmlDocumentHeaders(Buffer.byteLength(body)))
+      res.end(body)
+      return
+    }
+    if (review && url.pathname.startsWith('/api/review/')) {
+      let result
+      if (url.pathname === '/api/review/records') result = review.records()
+      else if (url.pathname === '/api/review/document') result = review.document(url.searchParams.get('repo'), url.searchParams.get('path'))
+      else if (url.pathname === '/api/review/run') {
+        const bound = loadBoundRun(reviewProject, url.searchParams.get('id'))
+        result = bound.ok ? {...bound, current:currentRunEligibility(reviewProject,bound)} : bound
+      } else if (url.pathname === '/api/review/handoff') result = review.handoff(url.searchParams.get('id'))
+      else result = {ok:false,status:404,error:'unknown review action'}
+      json(res, result.status, result)
+      return
+    }
+
     if (url.pathname === '/api/health') {
       json(res, 200, { ok: true, workspaceId })
       return

package/src/server/server.mjs

@@ -17,6 +17,7 @@ export async function runServerCommand(argv = process.argv.slice(2)) {
   const sidecar = createAtelierSidecarServer({
     workspaceRoot: project.outputRoot,
     stateDir: project.outputRoot,
+    reviewProject: argv.includes('--review') ? project : null,
     // argv > PORT env > default. Supervisors that assign a free port (preview
     // panes, dev harnesses) pass it via PORT, and an Atelier that ignores that
     // fights whatever already holds the canonical port instead of coexisting.