amorphous-cli 0.1.0

package/lib/commands.mjs

@@ -0,0 +1,736 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs'
+import { apiFetch } from './api.mjs'
+import { abstractsOrigin, appOrigin, projectMetaPath } from './config.mjs'
+import { recordsFromLocal, readProjectFiles, writeProjectFiles } from './files.mjs'
+import { ALIASES, printHelp, wantsHelp } from './help.mjs'
+import { loginWithMagicLink } from './login.mjs'
+
+const BOOL_FLAGS = new Set([
+  'json',
+  'help',
+  'none',
+  'live',
+  'apply',
+  'starred',
+  'archived',
+  'owned',
+  'member',
+  'open',
+  'closed',
+])
+
+function parseFlags(args) {
+  const flags = {}
+  const positional = []
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '-h' || a === '--help') {
+      flags.help = true
+      continue
+    }
+    if (a.startsWith('--')) {
+      const key = a.slice(2)
+      if (BOOL_FLAGS.has(key)) {
+        flags[key] = true
+        continue
+      }
+      const next = args[i + 1]
+      if (next && !next.startsWith('-')) {
+        flags[key] = next
+        i++
+      } else {
+        flags[key] = true
+      }
+    } else {
+      positional.push(a)
+    }
+  }
+  return { flags, positional }
+}
+
+function jsonMode(flags) {
+  return Boolean(flags.json)
+}
+
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2))
+}
+
+function readMeta(cwd) {
+  const path = projectMetaPath(cwd)
+  if (!existsSync(path)) return null
+  return JSON.parse(readFileSync(path, 'utf8'))
+}
+
+function writeMeta(cwd, abstractId) {
+  writeFileSync(projectMetaPath(cwd), JSON.stringify({ abstractId }, null, 2) + '\n')
+}
+
+function requireMeta(cwd) {
+  const meta = readMeta(cwd)
+  if (!meta?.abstractId) {
+    throw new Error('No .amorphous.json here. Run amorphous create first.')
+  }
+  return meta.abstractId
+}
+
+async function resolveAbstractId(cwd, flags, positional) {
+  if (flags.abstract) return flags.abstract
+  if (positional[0]) {
+    const token = positional[0]
+    if (/^[0-9a-f-]{36}$/i.test(token)) return token
+    const data = await apiFetch('/api/abstracts?view=all')
+    const hit = (data.abstracts || []).find(
+      (a) => a.name.toLowerCase() === token.toLowerCase(),
+    )
+    if (hit) return hit.id
+    throw new Error(`No abstract named “${token}”`)
+  }
+  try {
+    return requireMeta(cwd)
+  } catch {
+    throw new Error('Pass an abstract or run this from its directory.')
+  }
+}
+
+async function loadFolders() {
+  const meta = await apiFetch('/api/organise/meta')
+  return meta.all_collections || meta.collections || []
+}
+
+async function resolveFolder(token) {
+  if (!token) return null
+  const folders = await loadFolders()
+  const want = String(token)
+  const hit = folders.find(
+    (c) =>
+      c.id === want ||
+      c.path === want ||
+      c.name.toLowerCase() === want.toLowerCase(),
+  )
+  if (!hit) throw new Error(`No folder named “${token}”`)
+  return hit
+}
+
+function folderToken(flags) {
+  return flags.folder || flags.collection
+}
+
+function parseAccess(raw) {
+  const v = String(raw || 'view').trim().toLowerCase()
+  if (['view', 'user', 'can-view', 'can view'].includes(v)) return 'user'
+  if (['use', 'can-use', 'can use'].includes(v)) return 'use'
+  if (['edit', 'editor', 'can-edit', 'can edit'].includes(v)) return 'editor'
+  throw new Error('Access must be view, use, or edit.')
+}
+
+function accessLabel(role) {
+  if (role === 'owner') return 'Owner'
+  if (role === 'editor' || role === 'admin') return 'Can edit'
+  if (role === 'use') return 'Can use'
+  return 'Can view'
+}
+
+function listRow(row) {
+  const tags = (row.tags || []).join(', ')
+  return [
+    row.name,
+    row.id,
+    accessLabel(row.role),
+    row.starred ? 'starred' : null,
+    row.archived ? 'archived' : null,
+    row.collection_path ? `in ${row.collection_path}` : null,
+    tags ? `#${tags.replace(/,\s*/g, ' #')}` : null,
+    row.live_open ? 'open' : 'closed',
+  ]
+    .filter(Boolean)
+    .join(' · ')
+}
+
+function publicAbstract(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    role: row.role,
+    starred: row.starred,
+    archived: row.archived,
+    tags: row.tags || [],
+    folder: row.collection_path || null,
+    folder_id: row.collection_id || null,
+    open: Boolean(row.live_open),
+    updated_at: row.updated_at,
+  }
+}
+
+async function cmdLogin(rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('login')
+  const email = positional[0]
+  if (!email) throw new Error('Pass an email.')
+  await loginWithMagicLink(email.trim())
+}
+
+async function cmdCreate(cwd, rest) {
+  const { flags } = parseFlags(rest)
+  if (flags.help) return printHelp('create')
+  const data = await apiFetch('/api/abstracts', { method: 'POST' })
+  const id = data.id
+  writeMeta(cwd, id)
+  const name = typeof flags.name === 'string' ? flags.name.trim() : ''
+  if (name) {
+    await apiFetch(`/api/abstracts/${id}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ name }),
+    })
+  }
+  const folderName = folderToken(flags)
+  if (folderName) {
+    const folder = await resolveFolder(folderName)
+    await apiFetch(`/api/abstracts/${id}/filing`, {
+      method: 'PATCH',
+      body: JSON.stringify({ collection_id: folder.id }),
+    })
+  }
+  if (jsonMode(flags)) printJson({ id, name: name || 'Untitled' })
+  else console.log(id)
+}
+
+function takeAccess(flags, positional) {
+  if (flags.access || flags.role) {
+    return { access: flags.access || flags.role, rest: positional }
+  }
+  if (positional[0] && /^(view|use|edit|user|editor)$/i.test(positional[0])) {
+    return { access: positional[0], rest: positional.slice(1) }
+  }
+  return { access: 'view', rest: positional }
+}
+
+async function resolvePerson(abstractId, who) {
+  if (/^[0-9a-f-]{36}$/i.test(who) && !/@/.test(who)) return { userId: who }
+  const detail = await apiFetch(`/api/abstracts/${abstractId}`)
+  const needle = who.includes('@') ? who.split('@')[0].toLowerCase() : who.toLowerCase()
+  const hit = (detail.members || []).find((m) => {
+    const name = (m.name || '').toLowerCase()
+    return m.user_id === who || name === needle || name === who.toLowerCase()
+  })
+  if (hit) return { userId: hit.user_id }
+  if (who.includes('@')) return { email: who }
+  throw new Error('No person matches that.')
+}
+
+async function cmdInvite(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('invite')
+  const email = flags.email || positional[0]
+  if (!email) throw new Error('Pass an email.')
+  const afterEmail = flags.email ? positional : positional.slice(1)
+  const { access, rest: absArgs } = takeAccess(flags, afterEmail)
+  const id = await resolveAbstractId(cwd, flags, absArgs)
+  const role = parseAccess(access)
+  await apiFetch(`/api/abstracts/${id}/grant`, {
+    method: 'POST',
+    body: JSON.stringify({ email, role }),
+  })
+  console.log('Invited.')
+}
+
+async function cmdRemove(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('remove')
+  const who = flags.email || positional[0]
+  if (!who) throw new Error('Pass an email or id.')
+  const id = await resolveAbstractId(cwd, flags, positional.slice(flags.email ? 0 : 1))
+  const body = await resolvePerson(id, who)
+  await apiFetch(`/api/abstracts/${id}/revoke`, {
+    method: 'POST',
+    body: JSON.stringify(body),
+  })
+  console.log('Removed.')
+}
+
+async function cmdPeople(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('people')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  const detail = await apiFetch(`/api/abstracts/${id}`)
+  const people = (detail.members || []).map((m) => ({
+    id: m.user_id,
+    name: m.name,
+    access: accessLabel(m.role),
+    role: m.role,
+  }))
+  if (jsonMode(flags)) {
+    printJson({ people })
+    return
+  }
+  if (!people.length) {
+    console.log('No people yet.')
+    return
+  }
+  for (const p of people) {
+    console.log(`${p.name} · ${p.access} · ${p.id}`)
+  }
+}
+
+async function cmdPull(cwd, rest) {
+  const { flags } = parseFlags(rest)
+  if (flags.help) return printHelp('pull')
+  const id = requireMeta(cwd)
+  const detail = await apiFetch(`/api/abstracts/${id}`)
+  const records = await apiFetch(`/api/abstracts/${id}/records`)
+  const rows = records.records || []
+  const shared = rows.filter((r) => r.visibility !== 'private')
+  const priv = rows.filter((r) => r.visibility === 'private')
+  writeProjectFiles(cwd, {
+    html: detail.abstract.draft_html,
+    css: detail.abstract.draft_css,
+    js: detail.abstract.draft_js,
+    shared,
+    private: priv,
+  })
+  console.log('Pulled.')
+}
+
+async function cmdPush(cwd, rest) {
+  const { flags } = parseFlags(rest)
+  if (flags.help) return printHelp('push')
+  const id = requireMeta(cwd)
+  const localRecords = recordsFromLocal(cwd)
+  const { refused } = await apiFetch(`/api/abstracts/${id}/records`, {
+    method: 'POST',
+    body: JSON.stringify({ records: localRecords }),
+  })
+  if (refused?.length) {
+    console.error('Skipped (already live):', refused.join(', '))
+  }
+  const { html, css, js } = readProjectFiles(cwd)
+  await apiFetch(`/api/abstracts/${id}/push`, {
+    method: 'POST',
+    body: JSON.stringify({ html, css, js }),
+  })
+  console.log('Pushed.')
+}
+
+function urlsFor(id) {
+  return {
+    open: `${appOrigin().replace(/\/$/, '')}/a/${id}`,
+    preview: `${abstractsOrigin().replace(/\/$/, '')}/${id}/draft`,
+    live: `${abstractsOrigin().replace(/\/$/, '')}/${id}`,
+  }
+}
+
+async function cmdOpen(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('open')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  const urls = urlsFor(id)
+  if (jsonMode(flags)) printJson(urls)
+  else console.log(urls.open)
+}
+
+async function cmdPreview(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('preview')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  const urls = urlsFor(id)
+  if (jsonMode(flags)) printJson({ preview: urls.preview })
+  else console.log(urls.preview)
+}
+
+async function cmdPublish(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('publish')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  const live = Boolean(flags.live)
+  const version = await apiFetch(`/api/abstracts/${id}/publish`, {
+    method: 'POST',
+    body: JSON.stringify({ live }),
+  })
+  if (jsonMode(flags)) printJson({ id: version.id, label: version.label, live })
+  else console.log(live ? 'It’s live.' : 'Published.')
+}
+
+async function cmdLive(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('live')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  const detail = await apiFetch(`/api/abstracts/${id}`)
+  const versionId =
+    flags.version ||
+    detail.abstract.live_version_id ||
+    detail.versions?.[detail.versions.length - 1]?.id
+  if (!versionId) throw new Error('Nothing published yet.')
+  await apiFetch(`/api/abstracts/${id}/live`, {
+    method: 'POST',
+    body: JSON.stringify({ versionId }),
+  })
+  console.log('This is the live version.')
+}
+
+async function cmdVisibility(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('visibility')
+  const mode = String(positional[0] || '').toLowerCase()
+  if (mode !== 'anyone' && mode !== 'members') {
+    throw new Error('Pass anyone or members.')
+  }
+  const id = await resolveAbstractId(cwd, flags, positional.slice(1))
+  const detail = await apiFetch(`/api/abstracts/${id}`)
+  const versionId =
+    flags.version ||
+    detail.abstract.live_version_id ||
+    detail.versions?.[detail.versions.length - 1]?.id
+  if (!versionId) throw new Error('Nothing published yet.')
+  const open = mode === 'anyone'
+  await apiFetch(`/api/abstracts/${id}/open`, {
+    method: 'POST',
+    body: JSON.stringify({ versionId, open }),
+  })
+  console.log(
+    open ? 'Anyone can view this version.' : 'Only people you invite can view it.',
+  )
+}
+
+async function cmdList(rest) {
+  const { flags } = parseFlags(rest)
+  if (flags.help) return printHelp('list')
+  const params = new URLSearchParams()
+  const view = flags.view ? String(flags.view) : 'all'
+  params.set('view', view)
+  const folder = folderToken(flags)
+  if (folder) params.set('collection', String(folder))
+  if (flags.tag) params.set('tag', String(flags.tag))
+  if (flags.search) params.set('search', String(flags.search))
+  if (flags.space) params.set('space', String(flags.space))
+  for (const key of ['starred', 'archived', 'owned', 'member', 'open', 'closed']) {
+    if (flags[key]) params.set(key, 'true')
+  }
+  const data = await apiFetch(`/api/abstracts?${params}`)
+  const rows = data.abstracts || []
+  if (jsonMode(flags)) {
+    printJson({ abstracts: rows.map(publicAbstract) })
+    return
+  }
+  if (!rows.length) {
+    console.log('Nothing here.')
+    return
+  }
+  for (const row of rows) console.log(listRow(row))
+}
+
+async function cmdStar(cwd, rest, starred) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp(starred ? 'star' : 'unstar')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  await apiFetch(`/api/abstracts/${id}/filing`, {
+    method: 'PATCH',
+    body: JSON.stringify({ starred }),
+  })
+  console.log(starred ? 'Starred.' : 'Unstarred.')
+}
+
+async function cmdTag(cwd, rest, add) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp(add ? 'tag' : 'untag')
+  const tag = flags.tag || positional[1]
+  if (!tag || typeof tag !== 'string') throw new Error('Pass --tag <name>.')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  const data = await apiFetch('/api/abstracts?view=all')
+  const row = (data.abstracts || []).find((a) => a.id === id)
+  const tags = new Set(row?.tags || [])
+  if (add) tags.add(tag.trim().toLowerCase())
+  else tags.delete(tag.trim().toLowerCase())
+  await apiFetch(`/api/abstracts/${id}/filing`, {
+    method: 'PATCH',
+    body: JSON.stringify({ tags: [...tags] }),
+  })
+  console.log(add ? 'Tagged.' : 'Untagged.')
+}
+
+async function cmdMove(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('move')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  let collection_id = null
+  const token = folderToken(flags)
+  if (flags.none) {
+    collection_id = null
+  } else if (token) {
+    collection_id = (await resolveFolder(token)).id
+  } else {
+    throw new Error('Pass --folder <name> or --none.')
+  }
+  await apiFetch(`/api/abstracts/${id}/filing`, {
+    method: 'PATCH',
+    body: JSON.stringify({ collection_id }),
+  })
+  console.log(collection_id ? 'Moved to folder.' : 'No folder.')
+}
+
+async function cmdArchive(cwd, rest, archived) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp(archived ? 'archive' : 'restore')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  await apiFetch(`/api/abstracts/${id}/filing`, {
+    method: 'PATCH',
+    body: JSON.stringify({ archived }),
+  })
+  console.log(archived ? 'Archived.' : 'Restored.')
+}
+
+async function cmdSuggestFolder(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('suggest-folder')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  const data = await apiFetch(`/api/abstracts/${id}/organise`, {
+    method: 'POST',
+    body: JSON.stringify({ apply: Boolean(flags.apply) }),
+  })
+  const folders = await loadFolders()
+  const folderId = data.suggestion?.collection_id ?? null
+  const folder = folders.find((f) => f.id === folderId)
+  const payload = {
+    folder: folder?.path ?? null,
+    folder_id: folderId,
+    reason: data.suggestion?.collection_reason ?? null,
+    tags: data.suggestion?.tags ?? [],
+    applied: Boolean(data.applied),
+  }
+  if (jsonMode(flags)) {
+    printJson(payload)
+    return
+  }
+  if (flags.apply && folder) {
+    console.log('Moved to that folder.')
+    return
+  }
+  if (!folder) {
+    console.log('No folder to suggest.')
+    return
+  }
+  console.log(`Folder: ${folder.path}`)
+  if (payload.reason) console.log(payload.reason)
+  if (payload.tags.length) console.log(`Tags: ${payload.tags.join(', ')}`)
+}
+
+async function cmdRename(cwd, rest) {
+  const { flags, positional } = parseFlags(rest)
+  if (flags.help) return printHelp('rename')
+  const name = typeof flags.name === 'string' ? flags.name.trim() : ''
+  if (!name) throw new Error('Pass --name <name>.')
+  const id = await resolveAbstractId(cwd, flags, positional)
+  await apiFetch(`/api/abstracts/${id}`, {
+    method: 'PATCH',
+    body: JSON.stringify({ name }),
+  })
+  console.log('Renamed.')
+}
+
+async function cmdFolderNew(rest) {
+  const { flags, positional } = parseFlags(rest)
+  const name = flags.name || positional[0]
+  if (!name) throw new Error('Pass --name <name>.')
+  const data = await apiFetch('/api/organise/collections', {
+    method: 'POST',
+    body: JSON.stringify({
+      name,
+      parent_id: flags.parent && flags.parent !== 'none' ? flags.parent : null,
+    }),
+  })
+  if (jsonMode(flags)) printJson({ id: data.id, name: data.name })
+  else console.log(data.id, data.name)
+}
+
+async function cmdFolderList(rest) {
+  const { flags } = parseFlags(rest)
+  const folders = await loadFolders()
+  if (jsonMode(flags)) {
+    printJson({
+      folders: folders.map((f) => ({
+        id: f.id,
+        name: f.name,
+        path: f.path,
+        parent_id: f.parent_id,
+        abstracts: f.abstract_count,
+      })),
+    })
+    return
+  }
+  if (!folders.length) {
+    console.log('No folders yet.')
+    return
+  }
+  for (const f of folders) {
+    console.log(`${f.path} · ${f.id}`)
+  }
+}
+
+async function cmdFolderMove(rest) {
+  const { flags, positional } = parseFlags(rest)
+  const token = flags.id || positional[0]
+  if (!token) throw new Error('Pass a folder.')
+  if (flags.parent === undefined) {
+    throw new Error('Pass --parent <id|none>.')
+  }
+  const folder = await resolveFolder(token)
+  const parent_id =
+    !flags.parent || flags.parent === 'none' || flags.parent === 'null'
+      ? null
+      : (await resolveFolder(flags.parent)).id
+  await apiFetch(`/api/organise/collections/${folder.id}/move`, {
+    method: 'POST',
+    body: JSON.stringify({ parent_id }),
+  })
+  console.log('Moved folder.')
+}
+
+async function cmdFolderInvite(rest) {
+  const { flags, positional } = parseFlags(rest)
+  const token = positional[0]
+  const email = flags.email || positional[1]
+  if (!token || !email) throw new Error('Pass a folder and --email <email>.')
+  const folder = await resolveFolder(token)
+  await apiFetch(`/api/organise/collections/${folder.id}/invite`, {
+    method: 'POST',
+    body: JSON.stringify({ email }),
+  })
+  console.log('Invited.')
+}
+
+async function cmdFolderRemove(rest) {
+  const { flags, positional } = parseFlags(rest)
+  const token = positional[0]
+  const who = flags.email || positional[1]
+  if (!token || !who) throw new Error('Pass a folder and an email or id.')
+  const folder = await resolveFolder(token)
+  const body = /@/.test(who) ? { email: who } : { userId: who }
+  await apiFetch(`/api/organise/collections/${folder.id}/revoke`, {
+    method: 'POST',
+    body: JSON.stringify(body),
+  })
+  console.log('Removed.')
+}
+
+async function cmdFolderPeople(rest) {
+  const { flags, positional } = parseFlags(rest)
+  const token = positional[0]
+  if (!token) throw new Error('Pass a folder.')
+  const folder = await resolveFolder(token)
+  const share = await apiFetch(`/api/organise/collections/${folder.id}`)
+  const people = (share.people || []).map((m) => ({
+    id: m.user_id,
+    name: m.name,
+    access: accessLabel(m.role),
+    role: m.role,
+  }))
+  if (jsonMode(flags)) {
+    printJson({ folder: folder.path, people })
+    return
+  }
+  if (!people.length) {
+    console.log('No people yet.')
+    return
+  }
+  for (const p of people) {
+    console.log(`${p.name} · ${p.access} · ${p.id}`)
+  }
+}
+
+async function cmdFolder(rest) {
+  const { flags } = parseFlags(rest)
+  if (flags.help || !rest[0]) return printHelp('folder')
+  const [sub, ...tail] = rest
+  if (sub === 'new') return cmdFolderNew(tail)
+  if (sub === 'list') return cmdFolderList(tail)
+  if (sub === 'move') return cmdFolderMove(tail)
+  if (sub === 'invite') return cmdFolderInvite(tail)
+  if (sub === 'remove') return cmdFolderRemove(tail)
+  if (sub === 'people') return cmdFolderPeople(tail)
+  throw new Error('folder needs new, list, move, invite, remove, or people.')
+}
+
+async function cmdSpaceNew(rest) {
+  const { flags } = parseFlags(rest)
+  const name = flags.name || rest.find((a) => !a.startsWith('--'))
+  if (!name) throw new Error('Use folder new instead.')
+  const data = await apiFetch('/api/spaces', {
+    method: 'POST',
+    body: JSON.stringify({ name }),
+  })
+  console.log(data.id, data.name)
+}
+
+async function cmdSpaceMember(rest) {
+  const { flags, positional } = parseFlags(rest)
+  const spaceId = flags.space || positional[0]
+  const email = flags.email || positional[1]
+  if (!spaceId || !email) throw new Error('Use folder invite instead.')
+  await apiFetch(`/api/spaces/${spaceId}/members`, {
+    method: 'POST',
+    body: JSON.stringify({ email, role: flags.role || 'member' }),
+  })
+  console.log('Invited.')
+}
+
+export async function runCommand(argv, cwd = process.cwd()) {
+  if (!argv[0] || argv[0] === 'help' || argv[0] === '--help' || argv[0] === '-h') {
+    printHelp()
+    return
+  }
+  const [raw, ...rest] = argv
+  const cmd = ALIASES[raw] || raw
+  switch (cmd) {
+    case 'login':
+      return cmdLogin(rest)
+    case 'create':
+      return cmdCreate(cwd, rest)
+    case 'invite':
+      return cmdInvite(cwd, rest)
+    case 'remove':
+      return cmdRemove(cwd, rest)
+    case 'people':
+      return cmdPeople(cwd, rest)
+    case 'pull':
+      return cmdPull(cwd, rest)
+    case 'push':
+      return cmdPush(cwd, rest)
+    case 'open':
+      return cmdOpen(cwd, rest)
+    case 'preview':
+      return cmdPreview(cwd, rest)
+    case 'publish':
+      return cmdPublish(cwd, rest)
+    case 'live':
+      return cmdLive(cwd, rest)
+    case 'visibility':
+      return cmdVisibility(cwd, rest)
+    case 'list':
+      return cmdList(rest)
+    case 'star':
+      return cmdStar(cwd, rest, true)
+    case 'unstar':
+      return cmdStar(cwd, rest, false)
+    case 'tag':
+      return cmdTag(cwd, rest, true)
+    case 'untag':
+      return cmdTag(cwd, rest, false)
+    case 'move':
+      return cmdMove(cwd, rest)
+    case 'archive':
+      return cmdArchive(cwd, rest, true)
+    case 'restore':
+      return cmdArchive(cwd, rest, false)
+    case 'suggest-folder':
+      return cmdSuggestFolder(cwd, rest)
+    case 'folder':
+      return cmdFolder(rest)
+    case 'rename':
+      return cmdRename(cwd, rest)
+    case 'space':
+      if (rest[0] === 'new') return cmdSpaceNew(rest.slice(1))
+      if (rest[0] === 'member') return cmdSpaceMember(rest.slice(1))
+      throw new Error('Use folder instead.')
+    default:
+      throw new Error(`Unknown command “${raw}”. Run amorphous --help.`)
+  }
+}