amorphous-cli 0.1.13 → 0.3.0

package/lib/pull.test.mjs

@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+import { writePulledProject } from './commands.mjs'
+
+const detail = { abstract: {
+  draft_html: '<main>Editable</main>', draft_css: 'main{color:black}', draft_js: 'window.ready=true',
+  draft_recovery_contract: { version: 1, status: 'declared', privateReferences: [] },
+} }
+
+test('explicit pull writes editable source, empty data files, metadata, and the current contract', () => {
+  const cwd = mkdtempSync(join(tmpdir(), 'amorphous-pull-'))
+  writePulledProject(cwd, '00000000-0000-4000-8000-000000000001', detail, { records: [] }, { fresh: true })
+  assert.equal(readFileSync(join(cwd, 'index.html'), 'utf8'), detail.abstract.draft_html)
+  assert.equal(readFileSync(join(cwd, 'styles.css'), 'utf8'), detail.abstract.draft_css)
+  assert.equal(readFileSync(join(cwd, 'app.js'), 'utf8'), detail.abstract.draft_js)
+  assert.equal(readFileSync(join(cwd, 'data.ndjson'), 'utf8'), '')
+  assert.equal(readFileSync(join(cwd, 'private.ndjson'), 'utf8'), '')
+  const metadata = JSON.parse(readFileSync(join(cwd, '.amorphous.json'), 'utf8'))
+  assert.equal(metadata.abstractId, '00000000-0000-4000-8000-000000000001')
+  assert.deepEqual(metadata.recoveryContract, detail.abstract.draft_recovery_contract)
+  assert.ok(readdirSync(cwd).includes('AGENTS.md'))
+})
+
+test('explicit pull refuses a populated unrelated directory without changing it', () => {
+  const cwd = mkdtempSync(join(tmpdir(), 'amorphous-pull-'))
+  writeFileSync(join(cwd, 'notes.txt'), 'keep')
+  assert.throws(() => writePulledProject(cwd, '00000000-0000-4000-8000-000000000001', detail,
+    { records: [] }, { fresh: true }), /empty directory/)
+  assert.deepEqual(readdirSync(cwd), ['notes.txt'])
+  assert.equal(readFileSync(join(cwd, 'notes.txt'), 'utf8'), 'keep')
+})
+
+test('ordinary pull into an existing connected folder remains supported', () => {
+  const cwd = mkdtempSync(join(tmpdir(), 'amorphous-pull-'))
+  mkdirSync(join(cwd, 'keep'))
+  writePulledProject(cwd, '00000000-0000-4000-8000-000000000001', detail, { records: [] })
+  assert.equal(readFileSync(join(cwd, 'index.html'), 'utf8'), detail.abstract.draft_html)
+  assert.equal(statSync(join(cwd, 'keep')).isDirectory(), true)
+})

package/lib/recipe-create.test.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict'
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import test from 'node:test'
+import { writeRecipeFiles } from './commands.mjs'
+import { printHelp } from './help.mjs'
+
+test('recipe source writer saves the exact returned source bundle', () => {
+  const cwd = mkdtempSync(join(tmpdir(), 'amorphous-recipe-'))
+  const source = { html: '<h1>My app</h1>\n', css: 'body{color:black}\n', js: 'console.log("ok")\n' }
+  try {
+    writeRecipeFiles(cwd, source)
+    assert.equal(readFileSync(join(cwd, 'index.html'), 'utf8'), source.html)
+    assert.equal(readFileSync(join(cwd, 'styles.css'), 'utf8'), source.css)
+    assert.equal(readFileSync(join(cwd, 'app.js'), 'utf8'), source.js)
+    assert.equal(readFileSync(join(cwd, 'data.ndjson'), 'utf8'), '')
+    assert.equal(readFileSync(join(cwd, 'private.ndjson'), 'utf8'), '')
+  } finally { rmSync(cwd, { recursive: true, force: true }) }
+})
+
+test('recipe source writer refuses to overwrite an existing project file', () => {
+  const cwd = mkdtempSync(join(tmpdir(), 'amorphous-recipe-'))
+  try {
+    writeFileSync(join(cwd, 'app.js'), 'existing')
+    assert.throws(() => writeRecipeFiles(cwd, { html: '', css: '', js: 'new' }), /empty source folder/)
+    assert.equal(readFileSync(join(cwd, 'app.js'), 'utf8'), 'existing')
+  } finally { rmSync(cwd, { recursive: true, force: true }) }
+})
+
+test('create help documents recipe config mode', () => {
+  const previous = console.log
+  let output = ''
+  console.log = value => { output = String(value) }
+  try { printHelp('create') } finally { console.log = previous }
+  assert.match(output, /--recipe-config <file>/)
+})

package/lib/serve.mjs

@@ -2,12 +2,13 @@ import { createServer } from 'node:http'
 import { existsSync, readFileSync, watch } from 'node:fs'
 import { join } from 'node:path'
 import { apiFetch } from './api.mjs'
-import { cliAbstractsFetchOrigin, cliAbstractsHostHeader } from './config.mjs'
+import { randomUUID } from 'node:crypto'
 import { insertLocalRecord, readProjectFiles, recordsFromLocal, replaceLocalRecord } from './files.mjs'
 
 const BAR_CSS = `#amorphous-serve{position:fixed;z-index:2147483646;left:12px;bottom:12px;display:flex;gap:6px;align-items:center;padding:4px 6px 4px 10px;border-radius:999px;background:#18181b;color:#fff;font:500 12px/1 system-ui,-apple-system,sans-serif}
 #amorphous-serve button{border:0;border-radius:999px;padding:4px 8px;font:inherit;color:#a1a1aa;background:transparent;cursor:pointer}
 #amorphous-serve button[aria-pressed="true"]{background:#fff;color:#18181b}`
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
 
 function stripScriptTags(html) {
   return String(html || '').replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
@@ -28,7 +29,16 @@ function recordsMode(req, url) {
 
 async function readJson(req) {
   const chunks = []
-  for await (const chunk of req) chunks.push(chunk)
+  let length = 0
+  for await (const chunk of req) {
+    length += chunk.length
+    if (length > 64 * 1024) {
+      const error = new Error('Request too large')
+      error.status = 413
+      throw error
+    }
+    chunks.push(chunk)
+  }
   const text = Buffer.concat(chunks).toString('utf8')
   if (!text) return {}
   return JSON.parse(text)
@@ -44,7 +54,7 @@ function send(res, status, body, headers = {}) {
   res.end(payload)
 }
 
-function pageHtml(html, mode) {
+function pageHtml(html, mode, environment) {
   const pressed = (value) => (mode === value ? ' aria-pressed="true"' : '')
   return `<!DOCTYPE html>
 <html>
@@ -58,9 +68,15 @@ function pageHtml(html, mode) {
 <div id="amorphous-serve" data-mode="${mode}">
   <span>Records</span>
   <button type="button" data-set="local"${pressed('local')}>Local</button>
-  <button type="button" data-set="prod"${pressed('prod')}>Prod</button>
+  <button type="button" data-set="prod"${pressed('prod')}>${environment === 'preview' ? 'Preview' : 'Live'}</button>
 </div>
 <script>
+function recordFromResponse(payload) {
+  var body = payload && payload.body && typeof payload.body === 'object' ? payload.body : payload
+  return Object.assign({}, body, { id: payload.id, revision: payload.revision,
+    visibility: payload.visibility, collection: payload.collection,
+    created_by: payload.created_by == null ? null : payload.created_by })
+}
 window.amorphous = {
   login() {},
   async me() {
@@ -95,7 +111,20 @@ window.amorphous = {
         body: JSON.stringify(body)
       })
       if (!res.ok) throw new Error('insert failed: ' + res.status)
-      return body
+      return recordFromResponse(await res.json())
+    },
+    async history(recordId) {
+      const res = await fetch('/__amorphous/recovery/' + encodeURIComponent(recordId))
+      if (!res.ok) throw new Error('recovery history unavailable: ' + res.status)
+      return res.json()
+    },
+    async undo(recordId, historyId) {
+      const res = await fetch('/__amorphous/recovery/' + encodeURIComponent(recordId), {
+        method: 'POST', headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ historyId, operationKey: crypto.randomUUID() })
+      })
+      if (!res.ok) throw new Error('undo failed: ' + res.status)
+      return res.json()
     },
     async replace(id, row) {
       const res = await fetch('/__amorphous/data/' + encodeURIComponent(id), {
@@ -104,7 +133,7 @@ window.amorphous = {
         body: JSON.stringify(row)
       })
       if (!res.ok) throw new Error('replace failed: ' + res.status)
-      return row
+      return recordFromResponse(await res.json())
     }
   }
 }
@@ -126,66 +155,13 @@ new EventSource('/__amorphous/events').addEventListener('reload', function () {
 </html>`
 }
 
-function passFromResponse(res) {
-  const list = typeof res.headers.getSetCookie === 'function' ? res.headers.getSetCookie() : []
-  const lines = list.length ? list : [res.headers.get('set-cookie') || '']
-  for (const line of lines) {
-    const match = /(?:^|,\s*)am_pass=([^;]+)/.exec(line)
-    if (match) return `am_pass=${match[1]}`
-  }
-  return null
-}
-
-export async function mintAbstractPass(abstractId) {
-  const data = await apiFetch(`/api/abstracts/${abstractId}/code`, { method: 'POST', body: '{}' })
-  const code = data?.code
-  if (!code) throw new Error('Could not open the abstract records.')
-  const res = await fetch(`${cliAbstractsFetchOrigin()}/${abstractId}?code=${encodeURIComponent(code)}`, {
-    redirect: 'manual',
-    headers: { ...cliAbstractsHostHeader() },
-  })
-  const cookie = passFromResponse(res)
-  if (!cookie) throw new Error('Could not open the abstract records.')
-  return cookie
-}
-
-async function proxyAbstract(abstractId, path, init, session) {
-  const headers = {
-    ...cliAbstractsHostHeader(),
-    ...(init.headers || {}),
-  }
-  if (session.cookie) headers.Cookie = session.cookie
-  let res
-  try {
-    res = await fetch(`${cliAbstractsFetchOrigin()}/${abstractId}${path}`, {
-      method: init.method || 'GET',
-      headers,
-      body: init.body,
-      redirect: 'manual',
-    })
-  } catch {
-    return new Response(JSON.stringify({ message: 'Could not reach the abstract.' }), {
-      status: 502,
-      headers: { 'Content-Type': 'application/json' },
-    })
-  }
-  if (res.status === 401 && session.cookie && !init.retried) {
-    session.cookie = null
-    session.cookie = await session.mint()
-    return proxyAbstract(abstractId, path, { ...init, retried: true }, session)
-  }
-  return res
-}
-
 export function startServe(options) {
   const cwd = options.cwd
   const abstractId = options.abstractId
   const host = options.host || '127.0.0.1'
-  const session = {
-    cookie: null,
-    failed: false,
-    mint: options.mintPass || (() => mintAbstractPass(abstractId)),
-  }
+  const environment = options.environment === 'preview' ? 'preview' : 'production'
+  const appPath = `/api/v1/apps/${abstractId}`
+  const environmentQuery = `?environment=${environment}`
   const clients = new Set()
   let reloadTimer = null
 
@@ -203,42 +179,85 @@ export function startServe(options) {
     watchers.push(watch(path, notifyReload))
   }
 
-  async function ensurePass() {
-    if (session.cookie) return session.cookie
-    if (session.failed) return null
-    try {
-      session.cookie = await session.mint()
-      return session.cookie
-    } catch {
-      session.failed = true
-      return null
+  const hosted = (path, init = {}) => options.hostedFetch
+    ? options.hostedFetch(path, init)
+    : apiFetch(path, init)
+  const invoke = (name, input) => hosted(`${appPath}/actions/${name}/invoke${environmentQuery}`, {
+    method: 'POST', headers: { 'Idempotency-Key': randomUUID() }, body: JSON.stringify(input),
+  })
+  const recordFromOutput = (row) => ({ ...row.body, id: row.id, revision: row.revision,
+    visibility: row.visibility, collection: row.collection, created_by: row.created_by })
+  async function hostedRecords(method, url, req) {
+    if (method === 'GET' && url.pathname === '/__amorphous/data') {
+      const discovery = await hosted(`${appPath}/actions${environmentQuery}`)
+      const query = discovery.actions?.find((action) => action.name === 'records.query' && action.collection === 'default')
+      const limit = Math.min(100, query?.limits?.maxPage)
+      if (!Number.isSafeInteger(limit) || limit < 1) return { status: 503, body: { message: 'Invalid record page policy' } }
+      const records = []
+      for (const visibility of ['shared', 'private']) {
+        let cursor
+        const seen = new Set()
+        for (let pageNumber = 0; pageNumber < 1000; pageNumber++) {
+          const result = await invoke('records.query', { collection: 'default', visibility, limit,
+            ...(cursor ? { cursor } : {}) })
+          if (result.status !== 'ok') return { status: 403, body: { message: result.status } }
+          const page = Array.isArray(result.output) ? result.output : []
+          records.push(...page.map(recordFromOutput))
+          if (page.length < limit) break
+          cursor = page.at(-1)?.id
+          if (!cursor || seen.has(cursor)) return { status: 502, body: { message: 'Record cursor repeated' } }
+          seen.add(cursor)
+          if (pageNumber === 999) return { status: 413, body: { message: 'Record page limit reached' } }
+        }
+      }
+      return { status: 200, body: { records } }
     }
-  }
-
-  async function prod(path, init) {
-    if (options.prodFetch) return options.prodFetch(abstractId, path, init, session)
-    const cookie = await ensurePass()
-    if (!cookie && init.auth !== false) {
-      return new Response(JSON.stringify({ message: 'Not signed in. Run: amorphous-cli login' }), {
-        status: 401,
-        headers: { 'Content-Type': 'application/json' },
-      })
+    if (method === 'POST' && url.pathname === '/__amorphous/data') {
+      const row = await readJson(req)
+      if (!row || typeof row !== 'object' || Array.isArray(row)) return { status: 400, body: { message: 'Invalid record' } }
+      const { id, visibility = 'shared', revision: _revision, collection: _collection,
+        created_by: _author, user_id: _subject, ...body } = row
+      const result = await invoke('records.create', { collection: 'default', visibility, ...(id ? { id } : {}), body })
+      return { status: result.status === 'ok' ? 200 : result.status === 'conflict' ? 409 : 403,
+        body: result.status === 'ok' ? { ok: true, ...result.output } : { message: result.status } }
     }
-    const res = await proxyAbstract(abstractId, path, { ...init, headers: { ...(init.headers || {}), Cookie: cookie || '' } }, session)
-    const text = await res.text()
-    return new Response(text, { status: res.status, headers: { 'Content-Type': res.headers.get('content-type') || 'application/json' } })
+    if (method === 'PUT' && url.pathname.startsWith('/__amorphous/data/')) {
+      const id = decodeURIComponent(url.pathname.slice('/__amorphous/data/'.length))
+      const row = await readJson(req)
+      if (!row || typeof row !== 'object' || !Number.isSafeInteger(row.revision)) {
+        return { status: 400, body: { message: 'Current record revision required' } }
+      }
+      const { revision, id: _id, visibility = 'shared', collection: _collection,
+        created_by: _author, user_id: _subject, ...body } = row
+      const result = await invoke('records.patch', { collection: 'default', visibility, id,
+        expectedRevision: revision, body })
+      return { status: result.status === 'ok' ? 200 : result.status === 'conflict' ? 409 : 403,
+        body: result.status === 'ok' ? { ok: true, ...result.output } : { message: result.status } }
+    }
+    return { status: 405, body: { message: 'Method not allowed' } }
   }
 
   const server = createServer(async (req, res) => {
     try {
       const url = new URL(req.url || '/', 'http://127.0.0.1')
+      const address = server.address()
+      const expectedHost = `127.0.0.1:${address.port}`
+      if (req.headers.host !== expectedHost) {
+        send(res, 403, { message: 'Invalid local host' })
+        return
+      }
+      if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(req.method) &&
+        req.headers.origin !== `http://${expectedHost}`) {
+        send(res, 403, { message: 'Invalid local origin' })
+        return
+      }
       if (req.method === 'GET' && url.pathname === '/') {
         const mode = recordsMode(req, url)
         const headers = { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store' }
         if (url.searchParams.get('records') === 'local' || url.searchParams.get('records') === 'prod') {
           headers['Set-Cookie'] = `amorphous_records=${mode}; Path=/; SameSite=Lax`
         }
-        send(res, 200, pageHtml(readProjectFiles(cwd).html, mode), headers)
+        send(res, 200, pageHtml(readProjectFiles(cwd).html, mode, environment), headers)
         return
       }
       if (req.method === 'GET' && url.pathname === '/styles.css') {
@@ -267,40 +286,62 @@ export function startServe(options) {
         return
       }
       const mode = recordsMode(req, url)
+      const recoveryMatch = /^\/__amorphous\/recovery\/([^/]+)$/.exec(url.pathname)
+      if (recoveryMatch) {
+        let recordId
+        try { recordId = decodeURIComponent(recoveryMatch[1]) } catch { recordId = '' }
+        if (!UUID.test(recordId)) {
+          send(res, 400, { message: 'Invalid record id' })
+          return
+        }
+        if (mode !== 'prod') {
+          if (req.method === 'GET') send(res, 200, { revisions: [] })
+          else if (req.method === 'POST') send(res, 409, { message: 'Undo is available for hosted records only.' })
+          else send(res, 405, { message: 'Method not allowed' })
+          return
+        }
+        if (req.method === 'GET') {
+          const result = await hosted(`${appPath}/recovery/revisions?recordId=${encodeURIComponent(recordId)}${environmentQuery.replace('?', '&')}`)
+          send(res, 200, { revisions: Array.isArray(result?.revisions) ? result.revisions : [] })
+          return
+        }
+        if (req.method === 'POST') {
+          const body = await readJson(req)
+          if (!body || typeof body !== 'object' || Array.isArray(body) ||
+            Object.keys(body).sort().join(',') !== 'historyId,operationKey' ||
+            !UUID.test(String(body.historyId || '')) || !UUID.test(String(body.operationKey || ''))) {
+            send(res, 400, { message: 'Invalid recovery request' })
+            return
+          }
+          const revisions = await hosted(`${appPath}/recovery/revisions?recordId=${encodeURIComponent(recordId)}&environment=${environment}`)
+          if (!Array.isArray(revisions?.revisions) || !revisions.revisions.some((item) => item?.historyId === body.historyId)) {
+            send(res, 404, { message: 'Recovery revision unavailable' })
+            return
+          }
+          const result = await hosted(`${appPath}/recovery/revision?environment=${environment}`, {
+            method: 'POST', body: JSON.stringify({ historyId: body.historyId, operationKey: body.operationKey }),
+          })
+          send(res, 200, result)
+          return
+        }
+        send(res, 405, { message: 'Method not allowed' })
+        return
+      }
       if (req.method === 'GET' && url.pathname === '/__amorphous/me') {
-        const upstream = await prod('/api/me', { method: 'GET', auth: false })
-        const text = await upstream.text()
-        send(res, upstream.ok ? 200 : upstream.status, text, {
-          'Content-Type': 'application/json; charset=utf-8',
-        })
+        send(res, 200, await hosted(`${appPath}/me${environmentQuery}`))
         return
       }
       if (req.method === 'POST' && url.pathname === '/__amorphous/names') {
         const body = await readJson(req)
-        const upstream = await prod('/api/names', {
-          method: 'POST',
-          auth: false,
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ ids: Array.isArray(body.ids) ? body.ids : [] }),
-        })
-        const text = await upstream.text()
-        send(res, upstream.ok ? 200 : upstream.status, text, {
-          'Content-Type': 'application/json; charset=utf-8',
-        })
+        send(res, 200, await hosted(`${appPath}/names${environmentQuery}`, {
+          method: 'POST', body: JSON.stringify({ ids: Array.isArray(body.ids) ? body.ids : [] }),
+        }))
         return
       }
       if (url.pathname === '/__amorphous/data' || url.pathname.startsWith('/__amorphous/data/')) {
         if (mode === 'prod') {
-          const recordId = decodeURIComponent(url.pathname.slice('/__amorphous/data/'.length))
-          const path = req.method === 'PUT' ? `/api/data/${encodeURIComponent(recordId)}` : '/api/data'
-          const init = { method: req.method, auth: true }
-          if (req.method === 'POST' || req.method === 'PUT') {
-            init.headers = { 'Content-Type': 'application/json' }
-            init.body = JSON.stringify(await readJson(req))
-          }
-          const upstream = await prod(path, init)
-          const text = await upstream.text()
-          send(res, upstream.status, text, { 'Content-Type': 'application/json; charset=utf-8' })
+          const result = await hostedRecords(req.method, url, req)
+          send(res, result.status, result.body)
           return
         }
         if (req.method === 'GET') {
@@ -325,7 +366,7 @@ export function startServe(options) {
         send(res, 400, { message: 'Invalid request' })
         return
       }
-      send(res, 500, { message: error instanceof Error ? error.message : 'Request failed' })
+      send(res, error?.status || 500, { message: error instanceof Error ? error.message : 'Request failed' })
     }
   })