@webprodigies/morphite 0.2.0 → 0.2.1

package/bin/morphite.mjs

@@ -2,7 +2,7 @@
 /** SOURCE OF TRUTH KEYWORDS: terminalInstaller, installMorphite, INSTALLER_STEPS
  * WHAT: `npx @webprodigies/morphite` installs or updates the Mac app: checks the Mac, reads the
  *   latest release manifest, downloads the zip for this CPU with progress, checks its SHA-256,
- *   replaces the app in Applications and opens it with a short getting-started guide.
+ *   replaces the app in Applications and opens it. It prints a few quiet lines (INSTALLER_LOOK).
  * WHY: Until Morphite has a Developer ID, a browser download is stopped by Gatekeeper and people must
  *   allow it in Privacy & Security. A file fetched by this program is not marked as downloaded, so the
  *   verified app opens directly. Running the same command again is the update.
@@ -32,88 +32,54 @@ const PACKAGE = '@webprodigies/morphite'
 const EARLIER_APP_ID = 'com.webprodigies.morphite'
 
 // ── Presentation ────────────────────────────────────────────────────────────
+// INSTALLER_LOOK: quiet, Apple-like lines. A bold name, grey details, one thin progress bar with a
+// bold percentage; no logo art, boxes or check marks. One live line updates in place while work runs.
 const tty = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR && process.env.TERM !== 'dumb'
 const paint = (code) => (value) => (tty ? `\x1b[${code}m${value}\x1b[0m` : String(value))
 const bold = paint('1')
-const dim = paint('2')
-const grey = (shade) => paint(`38;5;${shade}`)
-const green = paint('38;5;114')
-const yellow = paint('38;5;221')
-const red = paint('38;5;203')
+const grey = paint('38;5;245')
 const width = () => process.stdout.columns || 80
+const say = (...lines) => { for (const line of lines) console.log(line) }
+/** A heading and a grey explanation, used for results and problems alike. */
+const note = (title, ...details) => say('', bold(title), ...details.map((detail) => grey(detail)))
 
-const LOGO = [
-  '███╗   ███╗ ██████╗ ██████╗ ██████╗ ██╗  ██╗██╗████████╗███████╗',
-  '████╗ ████║██╔═══██╗██╔══██╗██╔══██╗██║  ██║██║╚══██╔══╝██╔════╝',
-  '██╔████╔██║██║   ██║██████╔╝██████╔╝███████║██║   ██║   █████╗  ',
-  '██║╚██╔╝██║██║   ██║██╔══██╗██╔═══╝ ██╔══██║██║   ██║   ██╔══╝  ',
-  '██║ ╚═╝ ██║╚██████╔╝██║  ██║██║     ██║  ██║██║   ██║   ███████╗',
-  '╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝     ╚═╝  ╚═╝╚═╝   ╚═╝   ╚══════╝'
-]
-function banner(subtitle) {
-  console.log()
-  if (width() >= LOGO[0].length + 4) {
-    const shades = [255, 253, 251, 249, 246, 243]
-    LOGO.forEach((line, index) => console.log('  ' + grey(shades[index])(line)))
-  } else console.log('  ' + bold('M O R P H I T E'))
-  console.log()
-  console.log('  ' + subtitle)
-  console.log()
-}
-
-const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-const LABEL = 27
-/** One step line: a spinner while it runs, then ✓ with its result (or ✕ and the reason). */
-function step(label) {
-  let frame = 0
-  let detail = ''
-  let timer
-  const line = (mark) => `  ${mark} ${label.padEnd(LABEL)} ${detail}`
-  const draw = () => {
-    if (!tty) return
-    const text = line(grey(245)(FRAMES[(frame = (frame + 1) % FRAMES.length)]))
-    process.stdout.write('\r\x1b[2K' + text.slice(0, width() + 40))
-  }
-  if (tty) timer = setInterval(draw, 80)
-  draw()
-  const end = (mark, text) => {
-    clearInterval(timer)
-    detail = text ?? detail
-    process.stdout.write((tty ? '\r\x1b[2K' : '') + line(mark) + '\n')
+/** The one line that changes while work runs; `done` keeps its final text, `clear` removes it. */
+const live = {
+  text: '',
+  set(text) {
+    this.text = text
+    if (tty) process.stdout.write('\r\x1b[2K' + text)
+  },
+  done(text = this.text) {
+    if (tty) process.stdout.write('\r\x1b[2K')
+    if (text) console.log(text)
+    this.text = ''
+  },
+  clear() {
+    if (tty && this.text) process.stdout.write('\r\x1b[2K')
+    this.text = ''
   }
-  return {
-    update(text) {
-      detail = text
-      draw()
-    },
-    done: (text) => end(green('✓'), text && dim(text)),
-    fail: (text) => end(red('✕'), text && red(text)),
-    skip: (text) => end(grey(243)('–'), text && dim(text))
-  }
-}
-const megabytes = (bytes) => (bytes / 1e6).toFixed(1)
-function bar(ratio, size = Math.max(10, Math.min(28, width() - 64))) {
-  const filled = Math.round(ratio * size)
-  return grey(252)('━'.repeat(filled)) + grey(238)('━'.repeat(size - filled))
 }
-function box(title, lines) {
-  const inner = Math.max(title.length + 2, ...lines.map((entry) => entry.plain.length)) + 2
-  console.log('  ' + grey(243)('╭─ ') + bold(title) + ' ' + grey(243)('─'.repeat(Math.max(0, inner - title.length - 2)) + '╮'))
-  for (const entry of lines)
-    console.log('  ' + grey(243)('│') + '  ' + entry.text + ' '.repeat(inner - entry.plain.length - 1) + grey(243)('│'))
-  console.log('  ' + grey(243)('╰' + '─'.repeat(inner + 1) + '╯'))
+const megabytes = (bytes) => Math.round(bytes / 1e6).toString()
+const BAR = 26
+function bar(ratio) {
+  const filled = Math.round(Math.min(1, ratio) * BAR)
+  return paint('38;5;253')('━'.repeat(filled)) + paint('38;5;239')('━'.repeat(BAR - filled))
 }
-const row = (plain, text = plain) => ({ plain, text })
+const progressLine = (ratio, detail) => `${bar(ratio)}  ${bold(`${Math.floor(Math.min(1, ratio) * 100)}%`)}  ${grey(detail)}`
+/** "Morphite (Alpha)" is an Alpha release; a name without a stage is the latest release. */
+const stageOf = (name) => (name.match(/\(([^)]+)\)\s*$/)?.[1] ?? 'Latest') + ' release'
+const header = (name, version) => say('', bold(name), grey(version ? `${version} · ${stageOf(name)}` : 'Installer'), '')
 
 /** A yes only when the person types y (or --yes); Return alone, anything else or no keyboard cancels. */
 async function confirm(question) {
   if (flag('--yes')) return true
   if (!process.stdin.isTTY) {
-    console.log(`  ${dim('Run this command in Terminal to answer, or add --yes.')}`)
+    say(grey('Run this command in Terminal to answer, or add --yes.'))
     return false
   }
   const prompt = createInterface({ input: process.stdin, output: process.stdout })
-  const answer = await new Promise((resolve) => prompt.question(`  ${yellow('?')} ${question} `, resolve))
+  const answer = await new Promise((resolve) => prompt.question(`${bold(question)} ${grey('Type y to continue, anything else cancels')} `, resolve))
   prompt.close()
   return ['y', 'yes'].includes(answer.trim().toLowerCase())
 }
@@ -195,14 +161,7 @@ async function download(manifest, archive, folder, from, progress) {
   const destination = join(folder, archive.file)
   const hash = createHash('sha256')
   let received = 0
-  const started = Date.now()
-  const report = () => {
-    const seconds = Math.max(0.25, (Date.now() - started) / 1000)
-    progress(
-      `${bar(received / archive.size)} ${String(Math.floor((received / archive.size) * 100)).padStart(3)}%  ` +
-        dim(`${megabytes(received)} / ${megabytes(archive.size)} MB · ${megabytes(received / seconds)} MB/s`)
-    )
-  }
+  const report = () => progress(received / archive.size, `${megabytes(received)} of ${megabytes(archive.size)} MB`)
   const output = createWriteStream(destination, { mode: 0o600 })
   const write = async (chunk) => {
     hash.update(chunk)
@@ -226,7 +185,6 @@ async function download(manifest, archive, folder, from, progress) {
     clearInterval(timer)
     output.destroy()
   }
-  report()
   return { path: destination, sha256: hash.digest('hex'), size: received }
 }
 
@@ -239,46 +197,51 @@ async function writable(folder) {
 }
 async function main() {
   if (flag('--help') || flag('-h')) {
-    console.log(`\n  ${bold('npx ' + PACKAGE)}   Install or update Morphite on this Mac.\n\n  --yes       Answer yes to every question\n  --no-open   Do not open Morphite afterwards\n  --reinstall Install again even when this version is already installed\n  --from DIR  Install from a local release folder (for testing a release before publishing)\n`)
+    say('', bold('npx ' + PACKAGE), grey('Installs or updates Morphite on this Mac.'), '',
+      `--yes        ${grey('Answer yes to every question')}`,
+      `--no-open    ${grey('Do not open Morphite afterwards')}`,
+      `--reinstall  ${grey('Install again even when this version is installed')}`,
+      `--from DIR   ${grey('Install from a local release folder, to test a release before publishing')}`, '')
     return
   }
   const from = option('--from')
   if (platform() !== 'darwin') {
-    banner(bold('Morphite') + dim('  installer'))
-    console.log(`  ${yellow('!')} Morphite runs on macOS for now. Windows and Linux are on the way.`)
-    console.log(`    ${dim('Follow along at https://morphite.build')}\n`)
+    header('Morphite')
+    note('Morphite runs on macOS for now.', 'Windows and Linux are on the way. Follow along at https://morphite.build')
+    say('')
     process.exitCode = 1
     return
   }
 
-  const checking = step('Checking your Mac')
+  live.set(grey('Checking for the latest release…'))
   const macOS = (await run('/usr/bin/sw_vers', ['-productVersion'])).stdout.trim()
   const cpu = await macCpu()
-  checking.update(dim(`macOS ${macOS} · ${cpu === 'arm64' ? 'Apple silicon' : 'Intel'}`))
-
-  // The banner names the app from the release, so read it before printing anything else.
+  const chip = cpu === 'arm64' ? 'Apple silicon' : 'Intel'
+  // The header names the app and version from the release, so read it before printing anything else.
   let manifest
   try {
     manifest = await readManifest(from)
   } catch (error) {
-    checking.skip()
-    banner(bold('Morphite') + dim('  installer'))
-    console.log(`  ${red('✕')} ${error.message}\n`)
+    live.clear()
+    header('Morphite')
+    note('Morphite couldn’t be installed.', error.message)
+    say('')
     process.exitCode = 1
     return
   }
-  process.stdout.write(tty ? '\r\x1b[2K' : '')
-  banner(`${bold(manifest.name)} ${dim(`${manifest.version} · installer`)}`)
-  checking.done(`macOS ${macOS} · ${cpu === 'arm64' ? 'Apple silicon' : 'Intel'}`)
+  live.clear()
+  header(manifest.name, manifest.version)
+  say(grey(`macOS ${macOS} · ${chip}`))
   if (!versionAtLeast(macOS, manifest.minimumMacOS)) {
-    console.log(`\n  ${red('✕')} ${manifest.name} needs macOS ${manifest.minimumMacOS} or later. This Mac has ${macOS}.\n`)
+    note(`${manifest.name} needs macOS ${manifest.minimumMacOS} or later.`, `This Mac has macOS ${macOS}.`)
+    say('')
     process.exitCode = 1
     return
   }
   const archive = manifest.archives[cpu]
-  const release = step('Finding the latest release')
   if (!archive) {
-    release.fail(`No ${cpu === 'arm64' ? 'Apple silicon' : 'Intel'} build in this release.`)
+    note(`This release has no ${chip} build yet.`, 'Nothing was changed.')
+    say('')
     process.exitCode = 1
     return
   }
@@ -286,91 +249,86 @@ async function main() {
   const personal = join(homedir(), 'Applications')
   const installed = await appsWithId([applications, personal], manifest.bundleId)
   const current = installed.length ? await versionOf(installed[0]) : null
-  release.done(`${manifest.name} ${manifest.version}${current ? `  (installed: ${current})` : ''}`)
   const earlier = await appsWithId([applications, personal], EARLIER_APP_ID)
 
   // Already current (and nothing earlier to retire): say so and open it, without downloading again.
   if (current === manifest.version && !earlier.length && !flag('--reinstall')) {
-    if (!flag('--no-open')) await run('/usr/bin/open', [installed[0]]).catch(() => undefined)
-    console.log(`\n  ${green('✓')} ${manifest.name} ${manifest.version} is already installed ${dim(`(${tilde(installed[0])})`)}\n`)
+    const opened = !flag('--no-open') && (await run('/usr/bin/open', [installed[0]]).then(() => true, () => false))
+    note('You’re up to date.', `${manifest.name} ${manifest.version} is installed in ${dirname(installed[0]) === '/Applications' ? 'Applications' : tilde(dirname(installed[0]))}.${opened ? ' It’s open now.' : ''}`)
+    say('')
     return
   }
 
   // The earlier Morphite app (com.webprodigies.morphite): a new app replaces it and starts fresh.
   // Promise nothing about its data; this installer only moves the app itself to the Trash.
   if (earlier.length) {
-    const version = await versionOf(earlier[0])
-    console.log()
-    console.log(`  ${yellow('!')} Found ${bold(['Morphite', version].filter(Boolean).join(' '))} ${dim(`in ${earlier.map((app) => tilde(dirname(app))).join(', ')}`)}`)
-    console.log()
-    console.log(`    ${manifest.name} is a brand-new app. It replaces the earlier Morphite and starts fresh:`)
-    console.log(`    ${dim('•')} projects, chats and settings from the earlier app do not carry over`)
-    console.log(`    ${dim('•')} the earlier app moves to the Trash`)
-    console.log(`    ${dim('•')} your code and project folders are not touched`)
-    console.log()
-    console.log(`    If there is anything from the earlier app you want to keep, back it up before continuing.`)
-    console.log()
-    if (!(await confirm(`Type ${bold('y')} and press Return to continue, or anything else to cancel:`))) {
-      console.log(`\n  Cancelled. Nothing was changed.\n`)
+    note(
+      'An earlier Morphite is on this Mac.',
+      `${manifest.name} is a new app and starts fresh. Projects, chats and`,
+      'settings from the earlier app don’t carry over; it moves to the Trash.',
+      'Your code and project folders aren’t touched. Back up anything first.'
+    )
+    say('')
+    if (!(await confirm('Continue?'))) {
+      note('Cancelled.', 'Nothing was changed.')
+      say('')
       return
     }
+    say('')
   }
 
   const target = (await writable(applications)) ? applications : personal
+  const place = target === applications ? 'Applications' : tilde(target)
   const destination = join(target, `${manifest.name}.app`)
   const work = await mkdtemp(join(tmpdir(), 'morphite-installer-'))
   const cleanup = () => rm(work, { recursive: true, force: true }).catch(() => undefined)
   process.once('SIGINT', () => {
-    process.stdout.write('\n')
+    live.done()
     void cleanup().then(() => process.exit(130))
   })
+  // A problem after the download started: keep the last line where it stopped, then say what happened.
+  const stop = (title, detail) => {
+    live.done()
+    note(title, detail)
+    return Object.assign(Error(title), { reported: true })
+  }
   try {
-    const downloading = step('Downloading')
     let file
     try {
-      file = await download(manifest, archive, work, from, (text) => downloading.update(text))
+      file = await download(manifest, archive, work, from, (ratio, detail) => live.set(progressLine(ratio, detail)))
     } catch (error) {
-      downloading.fail(error.message)
-      throw Object.assign(error, { reported: true })
-    }
-    downloading.done(`${megabytes(file.size)} MB`)
-
-    const verifying = step('Verifying')
-    if (file.size !== archive.size || file.sha256 !== archive.sha256) {
-      verifying.fail('The download does not match the release checksum. Nothing was installed.')
-      throw Object.assign(Error('checksum'), { reported: true })
+      throw stop('The download stopped.', `${error.message} Nothing was changed.`)
     }
-    verifying.done('SHA-256 matches the release')
+    if (file.size !== archive.size || file.sha256 !== archive.sha256)
+      throw stop('The download doesn’t match the release.', 'Nothing was changed. Run the command again.')
+    live.done(progressLine(1, `${megabytes(file.size)} MB · verified`))
 
-    const unpacking = step('Unpacking')
+    live.set(grey(`${current ? 'Updating' : 'Installing'} in ${place}…`))
     await mkdir(target, { recursive: true })
     // Stage beside the destination so the final move is a rename on the same disk.
     const stage = await mkdtemp(join(target, '.morphite-install-'))
     try {
       await run('/usr/bin/ditto', ['-x', '-k', file.path, stage])
       const candidate = join(stage, `${manifest.name}.app`)
-      if ((await bundleIdOf(candidate)) !== manifest.bundleId) throw Error('The downloaded app is not the expected Morphite build.')
+      if ((await bundleIdOf(candidate)) !== manifest.bundleId) throw stop('The downloaded app isn’t the expected Morphite build.', 'Nothing was changed.')
       await run('/usr/bin/codesign', ['--verify', '--deep', '--strict', candidate]).catch(() => {
-        throw Error('The downloaded app failed its signature check. Nothing was installed.')
+        throw stop('The downloaded app failed its signature check.', 'Nothing was changed.')
       })
       // Fetched by this program, the app carries no download mark; clear one defensively all the same.
       await run('/usr/bin/xattr', ['-dr', 'com.apple.quarantine', candidate]).catch(() => undefined)
-      unpacking.done(manifest.name + '.app')
 
       // Morphite must be closed before its app is replaced; the person closes it, never this script.
       let open = await runningFrom([...installed, ...earlier])
       if (open.length) {
         const names = open.map((app) => basename(app, '.app')).join(' and ')
-        const waiting = step(`Closing ${names}`)
-        waiting.update(yellow(`Quit ${names} (⌘Q) to continue`))
+        live.set(`${bold(`Quit ${names} to continue`)} ${grey('(⌘Q)')}`)
         while (open.length) {
           await new Promise((resolve) => setTimeout(resolve, 700))
           open = await runningFrom([...installed, ...earlier])
         }
-        waiting.done('closed')
+        live.set(grey(`${current ? 'Updating' : 'Installing'} in ${place}…`))
       }
 
-      const installing = step(current ? 'Updating' : 'Installing')
       const replaced = []
       try {
         // Set the old app aside in the staging folder; it is removed with that folder only once the
@@ -381,42 +339,30 @@ async function main() {
           await rename(previous, aside)
           replaced.push([previous, aside])
         }
-        if (await stat(destination).catch(() => null)) throw Error(`${destination} already exists and is not ${manifest.name}.`)
+        if (await stat(destination).catch(() => null)) throw Error(`${tilde(destination)} already exists and isn’t ${manifest.name}.`)
         await rename(candidate, destination)
       } catch (error) {
         // Put every earlier copy back where it was; the install did not happen.
         for (const [original, moved] of replaced.reverse()) await rename(moved, original).catch(() => undefined)
-        installing.fail(error.message)
-        throw Object.assign(error, { reported: true })
+        if (error.reported) throw error
+        throw stop(`${manifest.name} couldn’t be installed.`, `${error.message} Nothing was changed.`)
       }
-      installing.done(destination.replace(homedir(), '~'))
+      live.done(grey(`${current ? 'Updated' : 'Installed'} in ${place}`))
     } finally {
       await rm(stage, { recursive: true, force: true }).catch(() => undefined)
     }
 
     // Agreed above: the earlier app goes to the Trash (recoverable); its data folder stays.
-    for (const app of earlier) {
-      const retiring = step('Retiring the earlier app')
-      if (await moveToTrash(app)) retiring.done(`${basename(app)} moved to the Trash`)
-      else retiring.skip(`drag ${basename(app)} from Applications to the Trash`)
-    }
+    for (const app of earlier)
+      say(grey((await moveToTrash(app)) ? 'Moved the earlier Morphite to the Trash' : `Drag ${basename(app)} from ${tilde(dirname(app))} to the Trash`))
 
-    if (!flag('--no-open')) {
-      const opening = step(`Opening ${manifest.name}`)
-      await run('/usr/bin/open', [destination]).then(
-        () => opening.done(),
-        () => opening.skip('open it from Applications')
-      )
-    }
-    console.log()
-    box(current ? `${manifest.name} is up to date` : `Welcome to ${manifest.name}`, [
-      row('1  Sign in with your Morphite account (your browser opens).', `${bold('1')}  Sign in with your Morphite account ${dim('(your browser opens)')}.`),
-      row('2  Connect Claude Code, Codex or another coding agent.', `${bold('2')}  Connect Claude Code, Codex or another coding agent.`),
-      row('3  Open a project folder, start a room and say what to build.', `${bold('3')}  Open a project folder, start a room and say what to build.`),
-      row(''),
-      row(`Update any time:  npx ${PACKAGE}@latest`, `${dim('Update any time:')}  ${bold(`npx ${PACKAGE}@latest`)}`)
-    ])
-    console.log()
+    const opened = !flag('--no-open') && (await run('/usr/bin/open', [destination]).then(() => true, () => false))
+    note(
+      `${manifest.name} is ready.`,
+      opened ? `It’s open now, and in ${place} and Spotlight.` : `Open it from ${place} or Spotlight.`,
+      'Run this command again to update.'
+    )
+    say('')
   } finally {
     await cleanup()
   }
@@ -424,11 +370,12 @@ async function main() {
 
 const [major] = process.versions.node.split('.').map(Number)
 if (major < 18) {
-  console.error(`\n  Morphite's installer needs Node.js 18 or later (you have ${process.versions.node}). Get it from https://nodejs.org\n`)
+  console.error(`\nMorphite’s installer needs Node.js 18 or later (you have ${process.versions.node}). Get it from https://nodejs.org\n`)
   process.exit(1)
 }
 main().catch((error) => {
-  if (!error?.reported) console.error(`\n  ${red('✕')} ${error?.message ?? error}\n`)
-  else console.log()
+  live.done()
+  if (!error?.reported) note('Morphite couldn’t be installed.', String(error?.message ?? error))
+  say('')
   process.exitCode = 1
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webprodigies/morphite",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Install or update Morphite on your Mac: npx @webprodigies/morphite",
   "type": "module",
   "bin": {