fedbox 0.0.1

package/README.md

@@ -0,0 +1,99 @@
+# 📦 Fedbox
+
+**Zero to Fediverse in 60 seconds.**
+
+Fedbox is the fastest way to get your own identity on the Fediverse. Run your own ActivityPub server, federate with Mastodon, and own your social presence.
+
+## Quick Start
+
+```bash
+# Install
+npm install -g fedbox
+
+# Set up your identity
+fedbox init
+
+# Start your server
+fedbox start
+```
+
+That's it. You're on the Fediverse.
+
+## Federation (so Mastodon can find you)
+
+To federate with the wider Fediverse, you need a public HTTPS URL. The easiest way:
+
+```bash
+# In another terminal
+ngrok http 3000
+```
+
+Copy your ngrok URL (e.g., `abc123.ngrok.io`) and add it to `fedbox.json`:
+
+```json
+{
+  "domain": "abc123.ngrok.io",
+  ...
+}
+```
+
+Restart your server, and you're federated! Search for `@yourname@abc123.ngrok.io` on Mastodon.
+
+## What You Get
+
+- **Your own identity** — `@you@yourdomain.com`
+- **ActivityPub compatible** — Works with Mastodon, Pleroma, Pixelfed, etc.
+- **Persistent storage** — SQLite database for followers, posts, activities
+- **Beautiful profile page** — Dark theme, looks great
+- **Zero config** — Just answer a few questions
+
+## Commands
+
+```bash
+fedbox init     # Set up your identity
+fedbox start    # Start the server
+fedbox status   # Show current config
+fedbox help     # Show help
+```
+
+## How It Works
+
+Fedbox uses [microfed](https://github.com/micro-fed/microfed.org) for ActivityPub primitives:
+
+- **Profile** — Your actor/identity
+- **Inbox** — Receive follows, likes, boosts
+- **Outbox** — Your posts
+- **WebFinger** — So others can find you
+
+Data is stored in SQLite (`data/fedbox.db`).
+
+## Configuration
+
+After `fedbox init`, you'll have a `fedbox.json`:
+
+```json
+{
+  "username": "alice",
+  "displayName": "Alice",
+  "summary": "Hello, Fediverse!",
+  "port": 3000,
+  "domain": null,
+  "publicKey": "...",
+  "privateKey": "..."
+}
+```
+
+Add `"domain"` for federation with the wider Fediverse.
+
+## Requirements
+
+- Node.js 18+
+- For federation: ngrok or a public server with HTTPS
+
+## License
+
+MIT
+
+---
+
+**Built with [microfed](https://github.com/micro-fed/microfed.org). Happy federating! 📦**

package/bin/cli.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+
+/**
+ * Pubcrawl CLI
+ * Zero to Fediverse in 60 seconds
+ */
+
+import { createInterface } from 'readline'
+import { existsSync, writeFileSync, mkdirSync } from 'fs'
+import { join } from 'path'
+import { generateKeypair } from 'microfed/auth'
+
+const rl = createInterface({
+  input: process.stdin,
+  output: process.stdout
+})
+
+const ask = (q) => new Promise(resolve => rl.question(q, resolve))
+
+const BANNER = `
+╔═══════════════════════════════════════════╗
+║                                           ║
+║   📦 FEDBOX                               ║
+║   Zero to Fediverse in 60 seconds         ║
+║                                           ║
+╚═══════════════════════════════════════════╝
+`
+
+const COMMANDS = {
+  init: runInit,
+  start: runStart,
+  status: runStatus,
+  help: runHelp
+}
+
+async function main() {
+  const command = process.argv[2] || 'help'
+  const handler = COMMANDS[command]
+
+  if (!handler) {
+    console.log(`Unknown command: ${command}`)
+    runHelp()
+    process.exit(1)
+  }
+
+  await handler()
+}
+
+async function runInit() {
+  console.log(BANNER)
+
+  // Check if already initialized
+  if (existsSync('fedbox.json')) {
+    console.log('⚠️  Already initialized. Delete fedbox.json to start over.\n')
+    process.exit(1)
+  }
+
+  console.log('Let\'s get you on the Fediverse!\n')
+
+  // Gather info
+  const username = await ask('👤 Username (e.g., alice): ')
+  const displayName = await ask('📛 Display name (e.g., Alice): ') || username
+  const summary = await ask('📝 Bio (optional): ') || ''
+  const port = await ask('🔌 Port (default 3000): ') || '3000'
+
+  console.log('\n🔐 Generating keypair...')
+  const { publicKey, privateKey } = generateKeypair()
+
+  // Create config
+  const config = {
+    username: username.toLowerCase().replace(/[^a-z0-9]/g, ''),
+    displayName,
+    summary,
+    port: parseInt(port),
+    publicKey,
+    privateKey,
+    createdAt: new Date().toISOString()
+  }
+
+  // Create data directory
+  if (!existsSync('data')) {
+    mkdirSync('data')
+  }
+
+  // Save config
+  writeFileSync('fedbox.json', JSON.stringify(config, null, 2))
+  console.log('✅ Config saved to fedbox.json')
+
+  console.log(`
+╔═══════════════════════════════════════════╗
+║  ✅ READY!                                ║
+╚═══════════════════════════════════════════╝
+
+Next steps:
+
+1. Start your server:
+   $ fedbox start
+
+2. Expose with ngrok (for federation):
+   $ ngrok http ${port}
+
+3. Update fedbox.json with your ngrok domain
+
+4. Visit your profile:
+   http://localhost:${port}/@${config.username}
+
+Happy federating! 📦
+`)
+
+  rl.close()
+}
+
+async function runStart() {
+  if (!existsSync('fedbox.json')) {
+    console.log('❌ Not initialized. Run: fedbox init\n')
+    process.exit(1)
+  }
+
+  console.log('🚀 Starting server...\n')
+
+  // Dynamic import to avoid loading before init
+  const { startServer } = await import('../lib/server.js')
+  await startServer()
+}
+
+async function runStatus() {
+  if (!existsSync('fedbox.json')) {
+    console.log('❌ Not initialized. Run: fedbox init\n')
+    process.exit(1)
+  }
+
+  const config = JSON.parse(await import('fs').then(fs =>
+    fs.readFileSync('fedbox.json', 'utf8')
+  ))
+
+  console.log(`
+╔═══════════════════════════════════════════╗
+║  📊 FEDBOX STATUS                         ║
+╚═══════════════════════════════════════════╝
+
+Username:  @${config.username}
+Name:      ${config.displayName}
+Port:      ${config.port}
+Domain:    ${config.domain || '(not set - run with ngrok)'}
+Created:   ${config.createdAt}
+`)
+
+  rl.close()
+}
+
+function runHelp() {
+  console.log(`
+${BANNER}
+Usage: fedbox <command>
+
+Commands:
+  init      Set up a new Fediverse identity
+  start     Start the server
+  status    Show current configuration
+  help      Show this help
+
+Quick start:
+  $ fedbox init
+  $ fedbox start
+
+For federation (so Mastodon can find you):
+  $ ngrok http 3000
+  Then update fedbox.json with your ngrok domain
+`)
+
+  rl.close()
+}
+
+main().catch(err => {
+  console.error('Error:', err.message)
+  process.exit(1)
+})

package/lib/server.js

@@ -0,0 +1,464 @@
+/**
+ * Fedbox Server
+ * ActivityPub server using microfed
+ */
+
+import { createServer } from 'http'
+import { readFileSync, existsSync } from 'fs'
+import { profile, auth, webfinger, outbox } from 'microfed'
+import {
+  initStore,
+  addFollower,
+  removeFollower,
+  getFollowers,
+  getFollowerCount,
+  addFollowing,
+  acceptFollowing,
+  getFollowingCount,
+  saveActivity,
+  getActivities,
+  savePost,
+  getPosts,
+  cacheActor,
+  getCachedActor
+} from './store.js'
+
+let config = null
+let actor = null
+
+/**
+ * Load configuration
+ */
+function loadConfig() {
+  if (!existsSync('fedbox.json')) {
+    throw new Error('Not initialized. Run: fedbox init')
+  }
+  config = JSON.parse(readFileSync('fedbox.json', 'utf8'))
+  return config
+}
+
+/**
+ * Get the domain (with ngrok support)
+ */
+function getDomain() {
+  return config.domain || `localhost:${config.port}`
+}
+
+/**
+ * Get protocol
+ */
+function getProtocol() {
+  return config.domain ? 'https' : 'http'
+}
+
+/**
+ * Build actor object
+ */
+function buildActor() {
+  const domain = getDomain()
+  const protocol = getProtocol()
+  const baseUrl = `${protocol}://${domain}`
+
+  return profile.createActor({
+    id: `${baseUrl}/users/${config.username}`,
+    username: config.username,
+    name: config.displayName,
+    summary: config.summary ? `<p>${config.summary}</p>` : '',
+    publicKey: config.publicKey,
+    sharedInbox: `${baseUrl}/inbox`
+  })
+}
+
+/**
+ * Fetch remote actor (with caching)
+ */
+async function fetchActor(id) {
+  const cached = getCachedActor(id)
+  if (cached) return cached
+
+  try {
+    const response = await fetch(id, {
+      headers: { 'Accept': 'application/activity+json' }
+    })
+    if (!response.ok) return null
+
+    const actorData = await response.json()
+    cacheActor(actorData)
+    return actorData
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Handle incoming activities
+ */
+async function handleActivity(activity) {
+  console.log(`📥 ${activity.type} from ${activity.actor}`)
+  saveActivity(activity)
+
+  switch (activity.type) {
+    case 'Follow':
+      await handleFollow(activity)
+      break
+    case 'Undo':
+      await handleUndo(activity)
+      break
+    case 'Accept':
+      handleAccept(activity)
+      break
+    case 'Create':
+      console.log(`   New post: ${activity.object?.content?.slice(0, 50)}...`)
+      break
+    case 'Like':
+      console.log(`   ❤️ Liked: ${activity.object}`)
+      break
+    case 'Announce':
+      console.log(`   🔁 Boosted: ${activity.object}`)
+      break
+  }
+}
+
+/**
+ * Handle Follow activity
+ */
+async function handleFollow(activity) {
+  const followerActor = await fetchActor(activity.actor)
+  if (!followerActor) {
+    console.log('   Could not fetch follower actor')
+    return
+  }
+
+  // Add to followers
+  addFollower(activity.actor, followerActor.inbox)
+  console.log(`   ✅ New follower: ${followerActor.preferredUsername}`)
+
+  // Send Accept
+  const accept = outbox.createAccept(actor.id, activity)
+
+  try {
+    await outbox.send({
+      activity: accept,
+      inbox: followerActor.inbox,
+      privateKey: config.privateKey,
+      keyId: `${actor.id}#main-key`
+    })
+    console.log(`   📤 Sent Accept to ${followerActor.inbox}`)
+  } catch (err) {
+    console.log(`   ❌ Failed to send Accept: ${err.message}`)
+  }
+}
+
+/**
+ * Handle Undo activity
+ */
+async function handleUndo(activity) {
+  if (activity.object?.type === 'Follow') {
+    removeFollower(activity.actor)
+    console.log(`   👋 Unfollowed by ${activity.actor}`)
+  }
+}
+
+/**
+ * Handle Accept activity (our follow was accepted)
+ */
+function handleAccept(activity) {
+  if (activity.object?.type === 'Follow') {
+    acceptFollowing(activity.object.object)
+    console.log(`   ✅ Follow accepted!`)
+  }
+}
+
+/**
+ * Request handler
+ */
+async function handleRequest(req, res) {
+  const url = new URL(req.url, `${getProtocol()}://${getDomain()}`)
+  const path = url.pathname
+  const accept = req.headers.accept || ''
+  const isAP = accept.includes('activity+json') || accept.includes('ld+json')
+
+  console.log(`${req.method} ${path}`)
+
+  // CORS
+  res.setHeader('Access-Control-Allow-Origin', '*')
+  res.setHeader('Access-Control-Allow-Headers', '*')
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204)
+    return res.end()
+  }
+
+  // WebFinger
+  if (path === '/.well-known/webfinger') {
+    const resource = url.searchParams.get('resource')
+    const parsed = webfinger.parseResource(resource)
+
+    if (!parsed || parsed.username !== config.username) {
+      res.writeHead(404)
+      return res.end('Not found')
+    }
+
+    const response = webfinger.createResponse(
+      `${config.username}@${getDomain()}`,
+      actor.id,
+      { profileUrl: `${getProtocol()}://${getDomain()}/@${config.username}` }
+    )
+
+    res.setHeader('Content-Type', 'application/jrd+json')
+    return res.end(JSON.stringify(response, null, 2))
+  }
+
+  // Actor
+  if (path === `/users/${config.username}`) {
+    res.setHeader('Content-Type', 'application/activity+json')
+    return res.end(JSON.stringify(actor, null, 2))
+  }
+
+  // Inbox
+  if (path === `/users/${config.username}/inbox` || path === '/inbox') {
+    if (req.method !== 'POST') {
+      res.writeHead(405)
+      return res.end('Method not allowed')
+    }
+
+    const chunks = []
+    for await (const chunk of req) chunks.push(chunk)
+    const body = Buffer.concat(chunks).toString()
+
+    try {
+      const activity = JSON.parse(body)
+      await handleActivity(activity)
+      res.writeHead(202)
+      return res.end()
+    } catch (err) {
+      console.error('Inbox error:', err)
+      res.writeHead(400)
+      return res.end('Bad request')
+    }
+  }
+
+  // Outbox
+  if (path === `/users/${config.username}/outbox`) {
+    const posts = getPosts(20)
+    const collection = {
+      '@context': 'https://www.w3.org/ns/activitystreams',
+      type: 'OrderedCollection',
+      id: `${actor.id}/outbox`,
+      totalItems: posts.length,
+      orderedItems: posts.map(p => ({
+        type: 'Create',
+        actor: actor.id,
+        object: {
+          type: 'Note',
+          id: p.id,
+          content: p.content,
+          published: p.published,
+          attributedTo: actor.id
+        }
+      }))
+    }
+    res.setHeader('Content-Type', 'application/activity+json')
+    return res.end(JSON.stringify(collection, null, 2))
+  }
+
+  // Followers
+  if (path === `/users/${config.username}/followers`) {
+    const followers = getFollowers()
+    const collection = {
+      '@context': 'https://www.w3.org/ns/activitystreams',
+      type: 'OrderedCollection',
+      id: `${actor.id}/followers`,
+      totalItems: followers.length,
+      orderedItems: followers.map(f => f.actor)
+    }
+    res.setHeader('Content-Type', 'application/activity+json')
+    return res.end(JSON.stringify(collection, null, 2))
+  }
+
+  // Following
+  if (path === `/users/${config.username}/following`) {
+    const collection = {
+      '@context': 'https://www.w3.org/ns/activitystreams',
+      type: 'OrderedCollection',
+      id: `${actor.id}/following`,
+      totalItems: getFollowingCount(),
+      orderedItems: []
+    }
+    res.setHeader('Content-Type', 'application/activity+json')
+    return res.end(JSON.stringify(collection, null, 2))
+  }
+
+  // HTML Profile
+  if (path === `/@${config.username}` || (path === `/users/${config.username}` && !isAP)) {
+    res.setHeader('Content-Type', 'text/html')
+    return res.end(renderProfile())
+  }
+
+  // Home
+  if (path === '/') {
+    res.setHeader('Content-Type', 'text/html')
+    return res.end(renderHome())
+  }
+
+  res.writeHead(404)
+  res.end('Not found')
+}
+
+/**
+ * Render HTML profile
+ */
+function renderProfile() {
+  const followers = getFollowerCount()
+  const following = getFollowingCount()
+
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>${config.displayName} (@${config.username}@${getDomain()})</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    * { box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 600px;
+      margin: 0 auto;
+      padding: 2rem;
+      background: #1a1a2e;
+      color: #eee;
+      min-height: 100vh;
+    }
+    .card {
+      background: #16213e;
+      border-radius: 16px;
+      padding: 2rem;
+      text-align: center;
+    }
+    .avatar {
+      width: 120px;
+      height: 120px;
+      border-radius: 50%;
+      background: linear-gradient(135deg, #667eea, #764ba2);
+      margin: 0 auto 1rem;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 3rem;
+    }
+    h1 { margin: 0 0 0.5rem; }
+    .handle { color: #888; margin-bottom: 1rem; }
+    .bio { color: #aaa; margin-bottom: 1.5rem; }
+    .stats { display: flex; justify-content: center; gap: 2rem; }
+    .stat { text-align: center; }
+    .stat-num { font-size: 1.5rem; font-weight: bold; }
+    .stat-label { color: #888; font-size: 0.9rem; }
+    .badge {
+      display: inline-block;
+      background: #667eea;
+      color: white;
+      padding: 0.5rem 1rem;
+      border-radius: 20px;
+      margin-top: 1.5rem;
+      font-size: 0.9rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="avatar">🍺</div>
+    <h1>${config.displayName}</h1>
+    <p class="handle">@${config.username}@${getDomain()}</p>
+    ${config.summary ? `<p class="bio">${config.summary}</p>` : ''}
+    <div class="stats">
+      <div class="stat">
+        <div class="stat-num">${followers}</div>
+        <div class="stat-label">Followers</div>
+      </div>
+      <div class="stat">
+        <div class="stat-num">${following}</div>
+        <div class="stat-label">Following</div>
+      </div>
+    </div>
+    <div class="badge">📦 Powered by Fedbox</div>
+  </div>
+</body>
+</html>`
+}
+
+/**
+ * Render home page
+ */
+function renderHome() {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Fedbox</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 600px;
+      margin: 0 auto;
+      padding: 2rem;
+      background: #1a1a2e;
+      color: #eee;
+    }
+    h1 { color: #667eea; }
+    a { color: #667eea; }
+    code { background: #16213e; padding: 0.2rem 0.4rem; border-radius: 4px; }
+    .endpoints { background: #16213e; padding: 1rem; border-radius: 8px; }
+    .endpoints li { margin: 0.5rem 0; }
+  </style>
+</head>
+<body>
+  <h1>📦 Fedbox</h1>
+  <p>Your Fediverse server is running!</p>
+
+  <h2>Your Profile</h2>
+  <p><a href="/@${config.username}">@${config.username}@${getDomain()}</a></p>
+
+  <h2>Endpoints</h2>
+  <ul class="endpoints">
+    <li><code>/.well-known/webfinger</code> - Discovery</li>
+    <li><code>/users/${config.username}</code> - Actor</li>
+    <li><code>/users/${config.username}/inbox</code> - Inbox</li>
+    <li><code>/users/${config.username}/outbox</code> - Outbox</li>
+    <li><code>/users/${config.username}/followers</code> - Followers</li>
+  </ul>
+
+  <h2>Federation</h2>
+  <p>To federate with Mastodon, expose this server via ngrok:</p>
+  <code>ngrok http ${config.port}</code>
+  <p>Then update <code>fedbox.json</code> with your ngrok domain.</p>
+</body>
+</html>`
+}
+
+/**
+ * Start the server
+ */
+export async function startServer() {
+  loadConfig()
+  initStore()
+  actor = buildActor()
+
+  const server = createServer(handleRequest)
+
+  server.listen(config.port, () => {
+    console.log(`
+📦 Fedbox is running!
+
+   Profile: http://localhost:${config.port}/@${config.username}
+   Actor:   http://localhost:${config.port}/users/${config.username}
+
+${config.domain ? `   Federated: https://${config.domain}/@${config.username}` : '   ⚠️  Set "domain" in fedbox.json for federation'}
+
+   Press Ctrl+C to stop
+`)
+  })
+}
+
+export default { startServer }

package/lib/store.js

@@ -0,0 +1,209 @@
+/**
+ * Fedbox Store
+ * SQLite persistence layer
+ */
+
+import Database from 'better-sqlite3'
+import { existsSync } from 'fs'
+
+let db = null
+
+/**
+ * Initialize the database
+ * @param {string} path - Path to SQLite file
+ */
+export function initStore(path = 'data/fedbox.db') {
+  db = new Database(path)
+
+  // Create tables
+  db.exec(`
+    -- Followers (people following us)
+    CREATE TABLE IF NOT EXISTS followers (
+      id TEXT PRIMARY KEY,
+      actor TEXT NOT NULL,
+      inbox TEXT,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    -- Following (people we follow)
+    CREATE TABLE IF NOT EXISTS following (
+      id TEXT PRIMARY KEY,
+      actor TEXT NOT NULL,
+      accepted INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    -- Activities (inbox)
+    CREATE TABLE IF NOT EXISTS activities (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      actor TEXT,
+      object TEXT,
+      raw TEXT NOT NULL,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    -- Posts (our outbox)
+    CREATE TABLE IF NOT EXISTS posts (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      in_reply_to TEXT,
+      published TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+
+    -- Known actors (cache)
+    CREATE TABLE IF NOT EXISTS actors (
+      id TEXT PRIMARY KEY,
+      data TEXT NOT NULL,
+      fetched_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+  `)
+
+  return db
+}
+
+/**
+ * Get database instance
+ */
+export function getStore() {
+  if (!db) {
+    throw new Error('Store not initialized. Call initStore() first.')
+  }
+  return db
+}
+
+// Followers
+
+export function addFollower(actorId, inbox) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO followers (id, actor, inbox)
+    VALUES (?, ?, ?)
+  `)
+  stmt.run(actorId, actorId, inbox)
+}
+
+export function removeFollower(actorId) {
+  const stmt = db.prepare('DELETE FROM followers WHERE id = ?')
+  stmt.run(actorId)
+}
+
+export function getFollowers() {
+  const stmt = db.prepare('SELECT * FROM followers ORDER BY created_at DESC')
+  return stmt.all()
+}
+
+export function getFollowerCount() {
+  const stmt = db.prepare('SELECT COUNT(*) as count FROM followers')
+  return stmt.get().count
+}
+
+// Following
+
+export function addFollowing(actorId, accepted = false) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO following (id, actor, accepted)
+    VALUES (?, ?, ?)
+  `)
+  stmt.run(actorId, actorId, accepted ? 1 : 0)
+}
+
+export function acceptFollowing(actorId) {
+  const stmt = db.prepare('UPDATE following SET accepted = 1 WHERE id = ?')
+  stmt.run(actorId)
+}
+
+export function removeFollowing(actorId) {
+  const stmt = db.prepare('DELETE FROM following WHERE id = ?')
+  stmt.run(actorId)
+}
+
+export function getFollowing() {
+  const stmt = db.prepare('SELECT * FROM following WHERE accepted = 1 ORDER BY created_at DESC')
+  return stmt.all()
+}
+
+export function getFollowingCount() {
+  const stmt = db.prepare('SELECT COUNT(*) as count FROM following WHERE accepted = 1')
+  return stmt.get().count
+}
+
+// Activities
+
+export function saveActivity(activity) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO activities (id, type, actor, object, raw)
+    VALUES (?, ?, ?, ?, ?)
+  `)
+  stmt.run(
+    activity.id,
+    activity.type,
+    typeof activity.actor === 'string' ? activity.actor : activity.actor?.id,
+    typeof activity.object === 'string' ? activity.object : JSON.stringify(activity.object),
+    JSON.stringify(activity)
+  )
+}
+
+export function getActivities(limit = 20) {
+  const stmt = db.prepare('SELECT * FROM activities ORDER BY created_at DESC LIMIT ?')
+  return stmt.all(limit).map(row => ({
+    ...row,
+    raw: JSON.parse(row.raw)
+  }))
+}
+
+// Posts
+
+export function savePost(id, content, inReplyTo = null) {
+  const stmt = db.prepare(`
+    INSERT INTO posts (id, content, in_reply_to)
+    VALUES (?, ?, ?)
+  `)
+  stmt.run(id, content, inReplyTo)
+}
+
+export function getPosts(limit = 20) {
+  const stmt = db.prepare('SELECT * FROM posts ORDER BY published DESC LIMIT ?')
+  return stmt.all(limit)
+}
+
+export function getPost(id) {
+  const stmt = db.prepare('SELECT * FROM posts WHERE id = ?')
+  return stmt.get(id)
+}
+
+// Actor cache
+
+export function cacheActor(actor) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO actors (id, data, fetched_at)
+    VALUES (?, ?, CURRENT_TIMESTAMP)
+  `)
+  stmt.run(actor.id, JSON.stringify(actor))
+}
+
+export function getCachedActor(id) {
+  const stmt = db.prepare('SELECT * FROM actors WHERE id = ?')
+  const row = stmt.get(id)
+  return row ? JSON.parse(row.data) : null
+}
+
+export default {
+  initStore,
+  getStore,
+  addFollower,
+  removeFollower,
+  getFollowers,
+  getFollowerCount,
+  addFollowing,
+  acceptFollowing,
+  removeFollowing,
+  getFollowing,
+  getFollowingCount,
+  saveActivity,
+  getActivities,
+  savePost,
+  getPosts,
+  getPost,
+  cacheActor,
+  getCachedActor
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "fedbox",
+  "version": "0.0.1",
+  "description": "Zero to Fediverse in 60 seconds",
+  "type": "module",
+  "main": "lib/server.js",
+  "bin": {
+    "fedbox": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node lib/server.js",
+    "test": "node --test test/"
+  },
+  "dependencies": {
+    "microfed": "^0.0.13",
+    "better-sqlite3": "^11.0.0"
+  },
+  "keywords": [
+    "activitypub",
+    "fediverse",
+    "mastodon",
+    "server",
+    "federation"
+  ],
+  "author": "Melvin Carvalho",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/micro-fed/fedbox"
+  }
+}