@webprodigies/morphite 0.2.0

package/README.md

@@ -0,0 +1,11 @@
+# Morphite
+
+Install or update Morphite on your Mac:
+
+```sh
+npx @webprodigies/morphite
+```
+
+The installer checks your Mac, downloads the latest release for Apple silicon or Intel, verifies its SHA-256 checksum, puts the app in Applications and opens it. Run the same command again to update. Your projects and settings live outside the app and are never changed by the installer.
+
+Requires macOS 12 or later and Node.js 18 or later. Windows and Linux are on the way.

package/bin/morphite.mjs

@@ -0,0 +1,434 @@
+#!/usr/bin/env node
+/** 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.
+ * 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.
+ * WHERE: ../manifest.mjs owns the release file format; scripts/release-publish.ts publishes releases;
+ *   the desktop app's Update action opens this command in Terminal. User data lives outside the app
+ *   bundle and is never touched here.
+ */
+import { createHash } from 'node:crypto'
+import { createWriteStream } from 'node:fs'
+import { access, constants, lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, rmdir, stat } from 'node:fs/promises'
+import { execFile } from 'node:child_process'
+import { homedir, platform, tmpdir, arch as nodeArch } from 'node:os'
+import { join, basename, dirname } from 'node:path'
+import { once } from 'node:events'
+import { createInterface } from 'node:readline'
+import { promisify } from 'node:util'
+import { INSTALL_MANIFEST_FILE, latestManifestUrl, parseInstallManifest, releaseFileUrl } from '../manifest.mjs'
+
+const run = promisify(execFile)
+const args = process.argv.slice(2)
+const flag = (name) => args.includes(name)
+const option = (name) => {
+  const index = args.indexOf(name)
+  return index >= 0 ? args[index + 1] : undefined
+}
+const PACKAGE = '@webprodigies/morphite'
+const EARLIER_APP_ID = 'com.webprodigies.morphite'
+
+// ── Presentation ────────────────────────────────────────────────────────────
+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 width = () => process.stdout.columns || 80
+
+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')
+  }
+  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 row = (plain, text = plain) => ({ plain, text })
+
+/** 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.')}`)
+    return false
+  }
+  const prompt = createInterface({ input: process.stdin, output: process.stdout })
+  const answer = await new Promise((resolve) => prompt.question(`  ${yellow('?')} ${question} `, resolve))
+  prompt.close()
+  return ['y', 'yes'].includes(answer.trim().toLowerCase())
+}
+
+// ── The Mac ─────────────────────────────────────────────────────────────────
+async function macCpu() {
+  if (nodeArch() === 'arm64') return 'arm64'
+  // An Intel build of Node under Rosetta still runs on Apple silicon; install the native app.
+  const translated = await run('/usr/sbin/sysctl', ['-in', 'sysctl.proc_translated']).then((r) => r.stdout.trim(), () => '0')
+  return translated === '1' ? 'arm64' : 'x64'
+}
+const versionAtLeast = (actual, minimum) => {
+  const [a, b] = [actual, minimum].map((value) => value.split('.').map(Number))
+  for (let index = 0; index < 3; index++) if ((a[index] ?? 0) !== (b[index] ?? 0)) return (a[index] ?? 0) > (b[index] ?? 0)
+  return true
+}
+async function bundleIdOf(app) {
+  return run('/usr/bin/plutil', ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', join(app, 'Contents/Info.plist')]).then(
+    (r) => r.stdout.trim(),
+    () => null
+  )
+}
+async function appsWithId(folders, id) {
+  const found = []
+  for (const folder of folders) {
+    const entries = await readdir(folder).catch(() => [])
+    for (const entry of entries) {
+      if (!entry.endsWith('.app')) continue
+      const path = join(folder, entry)
+      const info = await lstat(path).catch(() => null)
+      if (info?.isDirectory() && (await bundleIdOf(path)) === id) found.push(path)
+    }
+  }
+  return found
+}
+const versionOf = (app) =>
+  run('/usr/bin/plutil', ['-extract', 'CFBundleShortVersionString', 'raw', '-o', '-', join(app, 'Contents/Info.plist')]).then(
+    (r) => r.stdout.trim(),
+    () => null
+  )
+const tilde = (path) => path.replace(homedir(), '~')
+async function runningFrom(apps) {
+  const { stdout } = await run('/bin/ps', ['-axo', 'command='])
+  return apps.filter((app) => stdout.split('\n').some((command) => command.startsWith(join(app, 'Contents/MacOS') + '/')))
+}
+/** Asks Finder to move an app to the Trash (recoverable). macOS may first ask the person to let the
+ *  terminal use Finder; false when that is declined or Finder cannot move it. */
+async function moveToTrash(path) {
+  const script = `tell application "Finder" to delete (POSIX file ${JSON.stringify(path)} as alias)`
+  return run('/usr/bin/osascript', ['-e', script]).then(
+    () => true,
+    () => false
+  )
+}
+
+// ── Release ─────────────────────────────────────────────────────────────────
+async function fetchWithRetry(url, attempts = 3) {
+  let failure
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      const response = await fetch(url, { headers: { 'user-agent': `${PACKAGE} installer` }, redirect: 'follow' })
+      if (response.status === 404) return response
+      if (!response.ok) throw Error(`HTTP ${response.status}`)
+      return response
+    } catch (error) {
+      failure = error
+      await new Promise((resolve) => setTimeout(resolve, 600 * attempt))
+    }
+  }
+  throw Error(`Could not reach GitHub (${failure?.message ?? 'network error'}). Check your connection and run the command again.`)
+}
+async function readManifest(from) {
+  if (from) return parseInstallManifest(JSON.parse(await readFile(join(from, INSTALL_MANIFEST_FILE), 'utf8')))
+  const response = await fetchWithRetry(latestManifestUrl())
+  if (response.status === 404) throw Error('No Morphite release is available yet. Try again soon.')
+  return parseInstallManifest(await response.json())
+}
+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 output = createWriteStream(destination, { mode: 0o600 })
+  const write = async (chunk) => {
+    hash.update(chunk)
+    received += chunk.length
+    if (received > archive.size) throw Error('The download is larger than the release says. Nothing was installed.')
+    if (!output.write(chunk)) await once(output, 'drain')
+  }
+  const timer = setInterval(report, 120)
+  try {
+    if (from) {
+      const { createReadStream } = await import('node:fs')
+      for await (const chunk of createReadStream(join(from, archive.file))) await write(chunk)
+    } else {
+      const response = await fetchWithRetry(releaseFileUrl(manifest.tag, archive.file))
+      if (!response.ok || !response.body) throw Error(`The release file is unavailable (HTTP ${response.status}).`)
+      for await (const chunk of response.body) await write(chunk)
+    }
+    output.end()
+    await once(output, 'finish')
+  } finally {
+    clearInterval(timer)
+    output.destroy()
+  }
+  report()
+  return { path: destination, sha256: hash.digest('hex'), size: received }
+}
+
+// ── Install ─────────────────────────────────────────────────────────────────
+async function writable(folder) {
+  return access(folder, constants.W_OK).then(
+    () => true,
+    () => false
+  )
+}
+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`)
+    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`)
+    process.exitCode = 1
+    return
+  }
+
+  const checking = step('Checking your Mac')
+  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.
+  let manifest
+  try {
+    manifest = await readManifest(from)
+  } catch (error) {
+    checking.skip()
+    banner(bold('Morphite') + dim('  installer'))
+    console.log(`  ${red('✕')} ${error.message}\n`)
+    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'}`)
+  if (!versionAtLeast(macOS, manifest.minimumMacOS)) {
+    console.log(`\n  ${red('✕')} ${manifest.name} needs macOS ${manifest.minimumMacOS} or later. This Mac has ${macOS}.\n`)
+    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.`)
+    process.exitCode = 1
+    return
+  }
+  const applications = '/Applications'
+  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`)
+    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`)
+      return
+    }
+  }
+
+  const target = (await writable(applications)) ? applications : personal
+  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')
+    void cleanup().then(() => process.exit(130))
+  })
+  try {
+    const downloading = step('Downloading')
+    let file
+    try {
+      file = await download(manifest, archive, work, from, (text) => downloading.update(text))
+    } 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 })
+    }
+    verifying.done('SHA-256 matches the release')
+
+    const unpacking = step('Unpacking')
+    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.')
+      await run('/usr/bin/codesign', ['--verify', '--deep', '--strict', candidate]).catch(() => {
+        throw Error('The downloaded app failed its signature check. Nothing was installed.')
+      })
+      // 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`))
+        while (open.length) {
+          await new Promise((resolve) => setTimeout(resolve, 700))
+          open = await runningFrom([...installed, ...earlier])
+        }
+        waiting.done('closed')
+      }
+
+      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
+        // new app is in place, as any Mac updater does. The bundle holds no data: projects, settings
+        // and sign-in live outside it.
+        for (const previous of installed) {
+          const aside = join(stage, `previous-${replaced.length}.app`)
+          await rename(previous, aside)
+          replaced.push([previous, aside])
+        }
+        if (await stat(destination).catch(() => null)) throw Error(`${destination} already exists and is not ${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 })
+      }
+      installing.done(destination.replace(homedir(), '~'))
+    } 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`)
+    }
+
+    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()
+  } finally {
+    await cleanup()
+  }
+}
+
+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`)
+  process.exit(1)
+}
+main().catch((error) => {
+  if (!error?.reported) console.error(`\n  ${red('✕')} ${error?.message ?? error}\n`)
+  else console.log()
+  process.exitCode = 1
+})

package/manifest.mjs

@@ -0,0 +1,49 @@
+/** SOURCE OF TRUTH KEYWORDS: installManifest, INSTALL_MANIFEST, parseInstallManifest, INSTALL_MANIFEST_FILE
+ * WHAT: The one file a Morphite release carries for the terminal installer: the app's name, bundle
+ *   id and version, and for each Mac CPU the zipped app with its size and SHA-256.
+ * WHY: The installer trusts nothing it has not checked: it installs only releases that carry this
+ *   file (earlier releases without it are never picked up), checks every field before a path or URL
+ *   is built from it, and refuses an archive whose size or hash differs.
+ * WHERE: scripts/release-publish.ts writes it beside the zips; bin/morphite.mjs reads it from the
+ *   releases repository (or a local folder with --from). Plain JavaScript so the published installer
+ *   has no dependencies.
+ */
+export const INSTALL_MANIFEST_FILE = 'morphite-install.json'
+export const RELEASES_REPOSITORY = 'webprodigies-org/morphite-releases'
+export const MAC_ARCHES = ['arm64', 'x64']
+
+const text = (value, pattern, field) => {
+  if (typeof value !== 'string' || !pattern.test(value)) throw Error(`Release manifest: invalid ${field}.`)
+  return value
+}
+
+/** Returns a checked copy of the manifest, or throws naming the first invalid field. */
+export function parseInstallManifest(input) {
+  if (!input || typeof input !== 'object' || input.format !== 1) throw Error('Release manifest: unsupported format.')
+  const archives = {}
+  for (const arch of MAC_ARCHES) {
+    const entry = input.archives?.[arch]
+    if (!entry) continue
+    archives[arch] = {
+      file: text(entry.file, /^[A-Za-z0-9._-]+\.zip$/, `${arch} file`),
+      sha256: text(entry.sha256, /^[a-f0-9]{64}$/, `${arch} sha256`),
+      size: Number.isSafeInteger(entry.size) && entry.size > 0 ? entry.size : text('', /x/, `${arch} size`)
+    }
+  }
+  if (!Object.keys(archives).length) throw Error('Release manifest: no Mac archives.')
+  return {
+    format: 1,
+    // The app's folder name in Applications, e.g. "Morphite (Alpha)".
+    name: text(input.name, /^Morphite( \([A-Za-z0-9. ]{1,24}\))?$/, 'name'),
+    bundleId: text(input.bundleId, /^[a-z0-9]+(\.[a-z0-9-]+)+$/, 'bundle id'),
+    version: text(input.version, /^\d+\.\d+\.\d+$/, 'version'),
+    tag: text(input.tag, /^v\d+\.\d+\.\d+[A-Za-z0-9.-]*$/, 'tag'),
+    minimumMacOS: text(input.minimumMacOS, /^\d+(\.\d+)?$/, 'minimum macOS'),
+    archives
+  }
+}
+
+export const releaseFileUrl = (tag, file) =>
+  `https://github.com/${RELEASES_REPOSITORY}/releases/download/${encodeURIComponent(tag)}/${encodeURIComponent(file)}`
+export const latestManifestUrl = () =>
+  `https://github.com/${RELEASES_REPOSITORY}/releases/latest/download/${INSTALL_MANIFEST_FILE}`

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@webprodigies/morphite",
+  "version": "0.2.0",
+  "description": "Install or update Morphite on your Mac: npx @webprodigies/morphite",
+  "type": "module",
+  "bin": {
+    "morphite": "bin/morphite.mjs"
+  },
+  "files": [
+    "bin/morphite.mjs",
+    "manifest.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://morphite.build",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
+}