fedbox 0.0.4 → 0.0.6

package/lib/server.js

@@ -6,6 +6,7 @@
 
 import { createServer } from 'http'
 import { readFileSync, existsSync } from 'fs'
+import { join, extname } from 'path'
 import { profile, auth, webfinger, outbox } from 'microfed'
 import {
   initStore,
@@ -383,7 +384,7 @@ async function handleRequest(req, res) {
       version: '2.1',
       software: {
         name: 'fedbox',
-        version: '0.0.4',
+        version: '0.0.6',
         repository: 'https://github.com/micro-fed/fedbox'
       },
       protocols: ['activitypub'],
@@ -523,6 +524,25 @@ async function handleRequest(req, res) {
     return res.end(renderHome())
   }
 
+  // Static files from /public/
+  if (path.startsWith('/public/')) {
+    const filePath = join(process.cwd(), path)
+    if (existsSync(filePath)) {
+      const ext = extname(filePath)
+      const mimeTypes = {
+        '.js': 'application/javascript',
+        '.css': 'text/css',
+        '.html': 'text/html',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.svg': 'image/svg+xml'
+      }
+      res.setHeader('Content-Type', mimeTypes[ext] || 'text/plain')
+      return res.end(readFileSync(filePath))
+    }
+  }
+
   res.writeHead(404)
   res.end('Not found')
 }
@@ -576,7 +596,7 @@ function renderProfile() {
   <title>${config.displayName} (@${config.username}@${getDomain()})</title>
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <link rel="alternate" type="application/activity+json" href="${profileUrl}">
-  <script type="application/ld+json">
+  <script type="application/ld+json" id="profile">
 ${JSON.stringify(actor, null, 2)}
   </script>
   <style>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fedbox",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Zero to Fediverse in 60 seconds",
   "type": "module",
   "main": "lib/server.js",
@@ -9,11 +9,11 @@
   },
   "scripts": {
     "start": "node lib/server.js",
-    "test": "node --test test/"
+    "test": "node --test 'test/*.test.js'"
   },
   "dependencies": {
-    "microfed": "^0.0.13",
-    "better-sqlite3": "^11.0.0"
+    "better-sqlite3": "^11.0.0",
+    "microfed": "^0.0.14"
   },
   "keywords": [
     "activitypub",

package/public/profile.js

@@ -0,0 +1,151 @@
+/**
+ * Microfed Profile Component
+ * Reads JSON-LD data island and renders a profile card
+ *
+ * Usage: <script src="profile.js"></script>
+ * Requires: <script type="application/ld+json" id="profile">...</script>
+ */
+(function() {
+  'use strict'
+
+  function init() {
+    // Find JSON-LD data island
+    const script = document.querySelector('script[type="application/ld+json"]#profile') ||
+                   document.querySelector('script[type="application/ld+json"]')
+
+    if (!script) {
+      console.warn('Microfed Profile: No JSON-LD data island found')
+      return
+    }
+
+    let actor
+    try {
+      actor = JSON.parse(script.textContent)
+    } catch (e) {
+      console.error('Microfed Profile: Invalid JSON-LD', e)
+      return
+    }
+
+    // Find or create container
+    let container = document.getElementById('microfed-profile')
+    if (!container) {
+      container = document.createElement('div')
+      container.id = 'microfed-profile'
+      script.parentNode.insertBefore(container, script.nextSibling)
+    }
+
+    render(container, actor)
+  }
+
+  function render(container, actor) {
+    const name = actor.name || actor.preferredUsername || 'Unknown'
+    const username = actor.preferredUsername || ''
+    const summary = actor.summary || ''
+    const icon = actor.icon?.url || actor.icon || ''
+    const followers = actor.followers || ''
+    const following = actor.following || ''
+
+    container.innerHTML = `
+      <style>
+        .mf-profile {
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+          max-width: 400px;
+          border: 1px solid #e1e4e8;
+          border-radius: 8px;
+          padding: 20px;
+          background: #fff;
+        }
+        .mf-profile-header {
+          display: flex;
+          align-items: center;
+          gap: 16px;
+          margin-bottom: 12px;
+        }
+        .mf-profile-avatar {
+          width: 64px;
+          height: 64px;
+          border-radius: 50%;
+          object-fit: cover;
+          background: #e1e4e8;
+        }
+        .mf-profile-avatar-placeholder {
+          width: 64px;
+          height: 64px;
+          border-radius: 50%;
+          background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          color: white;
+          font-size: 24px;
+          font-weight: bold;
+        }
+        .mf-profile-name {
+          font-size: 1.25rem;
+          font-weight: 600;
+          margin: 0;
+          color: #24292e;
+        }
+        .mf-profile-username {
+          font-size: 0.875rem;
+          color: #586069;
+          margin: 2px 0 0 0;
+        }
+        .mf-profile-summary {
+          color: #24292e;
+          line-height: 1.5;
+          margin: 12px 0;
+        }
+        .mf-profile-stats {
+          display: flex;
+          gap: 16px;
+          margin-top: 12px;
+          padding-top: 12px;
+          border-top: 1px solid #e1e4e8;
+        }
+        .mf-profile-stat {
+          color: #586069;
+          font-size: 0.875rem;
+          text-decoration: none;
+        }
+        .mf-profile-stat:hover {
+          color: #0366d6;
+        }
+        .mf-profile-stat strong {
+          color: #24292e;
+        }
+      </style>
+      <div class="mf-profile">
+        <div class="mf-profile-header">
+          ${icon
+            ? `<img class="mf-profile-avatar" src="${escapeHtml(icon)}" alt="${escapeHtml(name)}">`
+            : `<div class="mf-profile-avatar-placeholder">${escapeHtml(name.charAt(0).toUpperCase())}</div>`
+          }
+          <div>
+            <h2 class="mf-profile-name">${escapeHtml(name)}</h2>
+            ${username ? `<p class="mf-profile-username">@${escapeHtml(username)}</p>` : ''}
+          </div>
+        </div>
+        ${summary ? `<div class="mf-profile-summary">${summary}</div>` : ''}
+        <div class="mf-profile-stats">
+          ${followers ? `<a class="mf-profile-stat" href="${escapeHtml(followers)}"><strong>Followers</strong></a>` : ''}
+          ${following ? `<a class="mf-profile-stat" href="${escapeHtml(following)}"><strong>Following</strong></a>` : ''}
+        </div>
+      </div>
+    `
+  }
+
+  function escapeHtml(str) {
+    if (!str) return ''
+    const div = document.createElement('div')
+    div.textContent = str
+    return div.innerHTML
+  }
+
+  // Initialize when DOM is ready
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init)
+  } else {
+    init()
+  }
+})()

package/test/actions.test.js

@@ -0,0 +1,78 @@
+/**
+ * Actions tests
+ */
+
+import { test, describe, before, after } from 'node:test'
+import assert from 'node:assert'
+import { writeFileSync, unlinkSync, existsSync, mkdirSync, rmSync } from 'fs'
+import { generateKeypair } from 'microfed/auth'
+
+function setupConfig(domain = null) {
+  const { publicKey, privateKey } = generateKeypair()
+  const config = {
+    username: 'alice',
+    displayName: 'Alice',
+    summary: 'Test user',
+    port: 3000,
+    publicKey,
+    privateKey
+  }
+  if (domain) config.domain = domain
+  writeFileSync('fedbox.json', JSON.stringify(config, null, 2))
+}
+
+function cleanup() {
+  if (existsSync('fedbox.json')) unlinkSync('fedbox.json')
+  if (existsSync('data/fedbox.db')) unlinkSync('data/fedbox.db')
+  try { rmSync('data', { recursive: true }) } catch {}
+}
+
+describe('Actions', () => {
+  before(() => {
+    cleanup()
+    if (!existsSync('data')) mkdirSync('data')
+    setupConfig()
+  })
+
+  after(() => {
+    cleanup()
+  })
+
+  test('post creates note with Solid-compatible noteId', async () => {
+    const { post } = await import('../lib/actions.js')
+    const result = await post('Hello world!')
+
+    // noteId should be /alice/posts/xxx (not /alice#me/posts/xxx)
+    assert.ok(result.noteId.includes('/alice/posts/'), 'noteId should include /alice/posts/')
+    assert.ok(!result.noteId.includes('#me/posts'), 'noteId should not have #me before /posts')
+    assert.ok(!result.noteId.includes('#me'), 'noteId should not contain #me at all')
+  })
+
+  test('post returns delivery results', async () => {
+    const { post } = await import('../lib/actions.js')
+    const result = await post('Test delivery')
+
+    assert.ok('delivered' in result, 'result should have delivered stats')
+    assert.ok('success' in result.delivered)
+    assert.ok('failed' in result.delivered)
+  })
+
+  test('myPosts returns saved posts', async () => {
+    const { myPosts } = await import('../lib/actions.js')
+    const posts = myPosts(10)
+    // Should have posts from previous tests
+    assert.ok(posts.length >= 1, 'should have at least 1 post')
+    assert.ok(posts[0].content, 'post should have content')
+    assert.ok(posts[0].id, 'post should have id')
+  })
+
+  test('myPosts posts have Solid-compatible URLs', async () => {
+    const { myPosts } = await import('../lib/actions.js')
+    const posts = myPosts(10)
+
+    for (const post of posts) {
+      assert.ok(post.id.includes('/alice/posts/'), 'post id should include /alice/posts/')
+      assert.ok(!post.id.includes('#me'), 'post id should not contain #me')
+    }
+  })
+})

package/test/store.test.js

@@ -0,0 +1,233 @@
+/**
+ * Store tests
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert'
+import { unlinkSync, existsSync, mkdirSync } from 'fs'
+import {
+  initStore,
+  getStore,
+  addFollower,
+  removeFollower,
+  getFollowers,
+  getFollowerCount,
+  addFollowing,
+  acceptFollowing,
+  getFollowing,
+  getFollowingCount,
+  savePost,
+  getPosts,
+  getPost,
+  cacheActor,
+  getCachedActor,
+  saveActivity,
+  getActivities
+} from '../lib/store.js'
+
+const TEST_DB = 'test/test.db'
+
+function cleanup() {
+  if (existsSync(TEST_DB)) {
+    unlinkSync(TEST_DB)
+  }
+}
+
+describe('Store', () => {
+  beforeEach(() => {
+    cleanup()
+    if (!existsSync('test')) mkdirSync('test', { recursive: true })
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('initStore creates database', () => {
+    assert.ok(existsSync(TEST_DB))
+  })
+
+  test('getStore returns database instance', () => {
+    const db = getStore()
+    assert.ok(db)
+  })
+})
+
+describe('Followers', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('addFollower and getFollowers', () => {
+    addFollower('https://example.com/user/alice', 'https://example.com/user/alice/inbox')
+    const followers = getFollowers()
+    assert.strictEqual(followers.length, 1)
+    assert.strictEqual(followers[0].actor, 'https://example.com/user/alice')
+    assert.strictEqual(followers[0].inbox, 'https://example.com/user/alice/inbox')
+  })
+
+  test('getFollowerCount', () => {
+    assert.strictEqual(getFollowerCount(), 0)
+    addFollower('https://example.com/user/alice', 'https://example.com/inbox')
+    assert.strictEqual(getFollowerCount(), 1)
+    addFollower('https://example.com/user/bob', 'https://example.com/inbox')
+    assert.strictEqual(getFollowerCount(), 2)
+  })
+
+  test('removeFollower', () => {
+    addFollower('https://example.com/user/alice', 'https://example.com/inbox')
+    assert.strictEqual(getFollowerCount(), 1)
+    removeFollower('https://example.com/user/alice')
+    assert.strictEqual(getFollowerCount(), 0)
+  })
+})
+
+describe('Following', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('addFollowing with pending status', () => {
+    addFollowing('https://example.com/user/bob', false)
+    assert.strictEqual(getFollowingCount(), 0) // Not accepted yet
+  })
+
+  test('acceptFollowing', () => {
+    addFollowing('https://example.com/user/bob', false)
+    assert.strictEqual(getFollowingCount(), 0)
+    acceptFollowing('https://example.com/user/bob')
+    assert.strictEqual(getFollowingCount(), 1)
+  })
+
+  test('getFollowing returns only accepted', () => {
+    addFollowing('https://example.com/user/bob', false)
+    addFollowing('https://example.com/user/charlie', true)
+    const following = getFollowing()
+    assert.strictEqual(following.length, 1)
+    assert.strictEqual(following[0].actor, 'https://example.com/user/charlie')
+  })
+})
+
+describe('Posts', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('savePost and getPost', () => {
+    const id = 'https://example.com/alice/posts/123'
+    savePost(id, 'Hello world!')
+    const post = getPost(id)
+    assert.ok(post)
+    assert.strictEqual(post.id, id)
+    assert.strictEqual(post.content, 'Hello world!')
+  })
+
+  test('savePost with inReplyTo', () => {
+    const id = 'https://example.com/alice/posts/456'
+    const replyTo = 'https://other.com/posts/789'
+    savePost(id, 'This is a reply', replyTo)
+    const post = getPost(id)
+    assert.strictEqual(post.in_reply_to, replyTo)
+  })
+
+  test('getPosts returns posts', () => {
+    savePost('https://example.com/posts/1', 'First')
+    savePost('https://example.com/posts/2', 'Second')
+    savePost('https://example.com/posts/3', 'Third')
+    const posts = getPosts(10)
+    assert.strictEqual(posts.length, 3)
+    // All posts should be present
+    const contents = posts.map(p => p.content)
+    assert.ok(contents.includes('First'))
+    assert.ok(contents.includes('Second'))
+    assert.ok(contents.includes('Third'))
+  })
+
+  test('getPosts respects limit', () => {
+    for (let i = 0; i < 10; i++) {
+      savePost(`https://example.com/posts/${i}`, `Post ${i}`)
+    }
+    const posts = getPosts(5)
+    assert.strictEqual(posts.length, 5)
+  })
+})
+
+describe('Actor Cache', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('cacheActor and getCachedActor', () => {
+    const actor = {
+      id: 'https://example.com/user/alice',
+      type: 'Person',
+      preferredUsername: 'alice'
+    }
+    cacheActor(actor)
+    const cached = getCachedActor(actor.id)
+    assert.deepStrictEqual(cached, actor)
+  })
+
+  test('getCachedActor returns null for unknown', () => {
+    const cached = getCachedActor('https://example.com/unknown')
+    assert.strictEqual(cached, null)
+  })
+})
+
+describe('Activities', () => {
+  beforeEach(() => {
+    cleanup()
+    initStore(TEST_DB)
+  })
+
+  afterEach(() => {
+    const db = getStore()
+    db.close()
+    cleanup()
+  })
+
+  test('saveActivity and getActivities', () => {
+    const activity = {
+      id: 'https://example.com/activity/1',
+      type: 'Create',
+      actor: 'https://example.com/user/alice',
+      object: { type: 'Note', content: 'Hello' }
+    }
+    saveActivity(activity)
+    const activities = getActivities(10)
+    assert.strictEqual(activities.length, 1)
+    assert.strictEqual(activities[0].type, 'Create')
+    assert.deepStrictEqual(activities[0].raw, activity)
+  })
+})