nappup 1.0.11 → 1.0.12

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Arthur França
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,75 @@
+# Napp Up!
+
+```text
+  _   _                   _   _       _
+ | \ | | __ _ _ __  _ __ | | | |_ __ | |
+ |  \| |/ _` | '_ \| '_ \| | | | '_ \| |
+ | |\  | (_| | |_) | |_) | |_| | |_) |_|
+ |_| \_|\__,_| .__/| .__/ \___/| .__/(_)
+             |_|   |_|         |_|
+```
+
+**Napp Up!** is a powerful CLI tool for developers to effortlessly upload and manage Nostr applications. Ship your decentralized apps to the Nostr network with a single command.
+
+## Usage
+
+```bash
+nappup [directory] [options]
+```
+
+### Arguments
+
+- `[directory]`
+  The root directory of your application to upload. If omitted, defaults to the current working directory (`.`).
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `-s <secret_key>` | Your Nostr secret key (hex format) used to sign the application event. See [Authentication](#authentication) for alternatives. |
+| `-d <d_tag>` | The unique identifier (`d` tag) for your application. If omitted, defaults to the directory name. Avoid generic names like `dist` or `build` - use something unique among your other apps like `mycoolapp`. |
+| `-r` | Force re-upload. By default, Napp Up! might skip files that haven't changed. Use this flag to ensure everything is pushed fresh. |
+| `--main` | Publish to the **main** release channel. This is the default behavior. |
+| `--next` | Publish to the **next** release channel. Ideal for beta testing or staging builds. |
+| `--draft` | Publish to the **draft** release channel. Use this for internal testing or work-in-progress builds. |
+
+## Authentication
+
+Napp Up! supports multiple ways to provide your Nostr secret key:
+
+1. **CLI flag**: Pass your hex-encoded secret key directly via `-s`:
+   ```bash
+   nappup -s 0123456789abcdef...
+   ```
+
+2. **Environment variable**: Set `NOSTR_SECRET_KEY` in your environment or a `.env` file:
+   ```bash
+   export NOSTR_SECRET_KEY=0123456789abcdef...
+   nappup ./dist
+   ```
+
+3. **Auto-generated key**: If no key is provided, Napp Up! will generate a new keypair automatically and store it in your project's `.env` file for future use.
+
+> **Note**: The secret key must be in **hex format**. If you have an `nsec`, convert it to hex first.
+
+### Examples
+
+Upload the current directory to the main channel:
+```bash
+nappup -s 0123456789abcdef...
+```
+
+Or using an environment variable:
+```bash
+NOSTR_SECRET_KEY=0123456789abcdef... nappup
+```
+
+Upload a specific `dist` folder with a custom identifier to the `next` channel:
+```bash
+nappup ./dist -s 0123456789abcdef... -d myapp --next
+```
+
+Force re-upload a draft:
+```bash
+nappup ~/my-repos/projectx/build/projectx --draft -r
+```

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "GPL-3.0-or-later",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {

package/src/helpers/app-metadata.js

@@ -0,0 +1,54 @@
+export function extractHtmlMetadata (htmlContent) {
+  let name
+  let description
+
+  try {
+    const titleRegex = /<title[^>]*>([\s\S]*?)<\/title>/i
+    const titleMatch = htmlContent.match(titleRegex)
+    if (titleMatch && titleMatch[1]) {
+      name = titleMatch[1].trim()
+    }
+
+    const metaDescRegex = /<meta\s+[^>]*name\s*=\s*["']description["'][^>]*content\s*=\s*["']([^"']+)["'][^>]*>/i
+    const metaDescMatch = htmlContent.match(metaDescRegex)
+    if (metaDescMatch && metaDescMatch[1]) {
+      description = metaDescMatch[1].trim()
+    }
+
+    if (!description) {
+      const altMetaDescRegex = /<meta\s+[^>]*content\s*=\s*["']([^"']+)["'][^>]*name\s*=\s*["']description["'][^>]*>/i
+      const altMetaDescMatch = htmlContent.match(altMetaDescRegex)
+      if (altMetaDescMatch && altMetaDescMatch[1]) {
+        description = altMetaDescMatch[1].trim()
+      }
+    }
+  } catch (_) {
+    // ignore
+  }
+
+  return { name, description }
+}
+
+export function findFavicon (fileList) {
+  const faviconExtensions = ['ico', 'svg', 'webp', 'png', 'jpg', 'jpeg', 'gif']
+  for (const file of fileList) {
+    const filename = (file.webkitRelativePath || file.name || '').split('/').pop().toLowerCase()
+    if (filename.startsWith('favicon.')) {
+      const ext = filename.split('.').pop()
+      if (faviconExtensions.includes(ext)) {
+        return file
+      }
+    }
+  }
+  return null
+}
+
+export function findIndexFile (fileList) {
+  for (const file of fileList) {
+    const filename = (file.webkitRelativePath || file.name || '').split('/').pop().toLowerCase()
+    if (filename === 'index.html' || filename === 'index.htm') {
+      return file
+    }
+  }
+  return null
+}

package/src/helpers/stream.js

@@ -18,3 +18,16 @@ export async function * streamToChunks (stream, chunkSize) {
 
   if (buffer.length > 0) yield buffer
 }
+
+export async function streamToText (stream) {
+  const reader = stream.getReader()
+  let result = ''
+  const decoder = new TextDecoder()
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    result += decoder.decode(value, { stream: true })
+  }
+  result += decoder.decode()
+  return result
+}

package/src/index.js

@@ -3,8 +3,9 @@ import { appEncode } from '#helpers/nip19.js'
 import Base93Encoder from '#services/base93-encoder.js'
 import nostrRelays from '#services/nostr-relays.js'
 import NostrSigner from '#services/nostr-signer.js'
-import { streamToChunks } from '#helpers/stream.js'
+import { streamToChunks, streamToText } from '#helpers/stream.js'
 import { isNostrAppDTagSafe, deriveNostrAppDTag } from '#helpers/app.js'
+import { extractHtmlMetadata, findFavicon, findIndexFile } from '#helpers/app-metadata.js'
 
 export default async function (...args) {
   try {
@@ -33,6 +34,21 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, chan
   let nmmr
   const fileMetadata = []
 
+  const indexFile = findIndexFile(fileList)
+  let stallName, stallSummary
+  if (indexFile) {
+    try {
+      const htmlContent = await streamToText(indexFile.stream())
+      const { name, description } = extractHtmlMetadata(htmlContent)
+      stallName = name
+      stallSummary = description
+    } catch (err) {
+      log('Error extracting HTML metadata:', err)
+    }
+  }
+  const faviconFile = findFavicon(fileList)
+  let iconMetadata
+
   log(`Processing ${fileList.length} files`)
   let pause = 1000
   for (const file of fileList) {
@@ -54,9 +70,29 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, chan
         filename,
         mimeType: file.type || 'application/octet-stream'
       })
+
+      if (faviconFile && file === faviconFile) {
+        iconMetadata = {
+          rootHash: nmmr.getRoot(),
+          mimeType: file.type || 'application/octet-stream'
+        }
+      }
     }
   }
 
+  log(`Uploading stall event for #${dTag}`)
+  ;({ pause } = (await maybeUploadStall({
+    dTag,
+    channel,
+    name: stallName,
+    summary: stallSummary,
+    icon: iconMetadata,
+    signer: nostrSigner,
+    writeRelays,
+    log,
+    pause
+  })))
+
   log(`Uploading bundle #${dTag}`)
   const bundle = await uploadBundle({ dTag, channel, fileMetadata, signer: nostrSigner, pause })
 
@@ -203,3 +239,156 @@ async function uploadBundle ({ dTag, channel, fileMetadata, signer, pause = 0 })
   await throttledSendEvent(event, (await signer.getRelays()).write, { pause, trailingPause: true })
   return event
 }
+
+async function maybeUploadStall ({
+  dTag,
+  channel,
+  name,
+  summary,
+  icon,
+  signer,
+  writeRelays,
+  log,
+  pause
+}) {
+  const trimmedName = typeof name === 'string' ? name.trim() : ''
+  const trimmedSummary = typeof summary === 'string' ? summary.trim() : ''
+  const iconRootHash = icon?.rootHash
+  const iconMimeType = icon?.mimeType
+  const hasMetadata = Boolean(trimmedName) || Boolean(trimmedSummary) || Boolean(iconRootHash)
+
+  const previous = await getPreviousStall(dTag, writeRelays, signer, channel)
+  if (!previous && !hasMetadata) return { pause }
+
+  const publishStall = async (event) => {
+    const signedEvent = await signer.signEvent(event)
+    return await throttledSendEvent(signedEvent, writeRelays, { pause, log, trailingPause: true })
+  }
+
+  const createdAt = Math.floor(Date.now() / 1000)
+  const kind = {
+    main: 37348,
+    next: 37349,
+    draft: 37350
+  }[channel] ?? 37348
+
+  if (!previous) {
+    const tags = [
+      ['d', dTag],
+      ['c', '*']
+    ]
+
+    let hasIcon = false
+    let hasName = false
+    if (iconRootHash && iconMimeType) {
+      hasIcon = true
+      tags.push(['icon', iconRootHash, iconMimeType])
+      tags.push(['auto', 'icon'])
+    }
+
+    if (trimmedName) {
+      hasName = true
+      tags.push(['name', trimmedName])
+      tags.push(['auto', 'name'])
+    }
+
+    if (trimmedSummary) {
+      tags.push(['summary', trimmedSummary])
+      tags.push(['auto', 'summary'])
+    }
+
+    if (!hasIcon || !hasName) return { pause }
+
+    return await publishStall({
+      kind,
+      tags,
+      content: '',
+      created_at: createdAt
+    })
+  }
+
+  const tags = Array.isArray(previous.tags)
+    ? previous.tags.map(tag => (Array.isArray(tag) ? [...tag] : tag))
+    : []
+  let changed = false
+
+  const ensureTagValue = (key, updater) => {
+    const index = tags.findIndex(tag => Array.isArray(tag) && tag[0] === key)
+    if (index === -1) {
+      const next = updater(null)
+      if (!next) return
+      tags.push(next)
+      changed = true
+      return
+    }
+
+    const next = updater(tags[index])
+    if (!next) return
+    if (!tags[index] || tags[index].some((value, idx) => value !== next[idx])) {
+      tags[index] = next
+      changed = true
+    }
+  }
+
+  ensureTagValue('d', (existing) => {
+    if (existing && existing[1] === dTag) return existing
+    return ['d', dTag]
+  })
+
+  ensureTagValue('c', (existing) => {
+    if (!existing) return ['c', '*']
+    const currentValue = typeof existing[1] === 'string' ? existing[1].trim() : ''
+    if (currentValue === '') return ['c', '*']
+    return existing
+  })
+
+  const hasAuto = (field) => tags.some(tag => Array.isArray(tag) && tag[0] === 'auto' && tag[1] === field)
+
+  if (trimmedName && hasAuto('name')) {
+    ensureTagValue('name', (existing) => {
+      if (existing && existing[1] === trimmedName) return existing
+      return ['name', trimmedName]
+    })
+  }
+
+  if (trimmedSummary && hasAuto('summary')) {
+    ensureTagValue('summary', (existing) => {
+      if (existing && existing[1] === trimmedSummary) return existing
+      return ['summary', trimmedSummary]
+    })
+  }
+
+  if (iconRootHash && iconMimeType && hasAuto('icon')) {
+    ensureTagValue('icon', (existing) => {
+      if (existing && existing[1] === iconRootHash && existing[2] === iconMimeType) return existing
+      return ['icon', iconRootHash, iconMimeType]
+    })
+  }
+
+  if (!changed) return { pause }
+
+  return await publishStall({
+    kind,
+    tags,
+    content: typeof previous.content === 'string' ? previous.content : '',
+    created_at: createdAt
+  })
+}
+
+async function getPreviousStall (dTagValue, writeRelays, signer, channel) {
+  const kind = {
+    main: 37348,
+    next: 37349,
+    draft: 37350
+  }[channel] ?? 37348
+
+  const storedEvents = (await nostrRelays.getEvents({
+    kinds: [kind],
+    authors: [await signer.getPublicKey()],
+    '#d': [dTagValue],
+    limit: 1
+  }, writeRelays)).result
+
+  if (storedEvents.length === 0) return null
+  return storedEvents.sort((a, b) => b.created_at - a.created_at)[0]
+}