@dtudury/streamo 0.1.2 → 0.2.0

package/.claude/settings.local.json

@@ -6,7 +6,9 @@
       "Bash(git push *)",
       "Bash(gh repo *)",
       "Bash(git rm *)",
-      "Bash(node --test)"
+      "Bash(node --test)",
+      "Bash(node --input-type=module --eval \"import './bin/streamo.js'\" --help)",
+      "Bash(node bin/streamo.js --help)"
     ]
   }
 }

package/README.md

@@ -50,7 +50,6 @@ streamo --env-file .env
 | `STREAMO_OUTLET` | `--outlet` | accept inbound peer connections |
 | `STREAMO_ORIGIN` | `--origin` | connect to a remote outlet |
 | `STREAMO_S3_BUCKET` | `--s3-bucket` | S3 bucket for replication |
-| `STREAMO_CHAT_ROOM` | `--chat-room` | auto-accept member announcements; this node's key becomes the room address |
 
 ## javascript api
 
@@ -184,10 +183,11 @@ For hot-reloading, `componentKey(prefix, address)` and `defineComponent(name, fn
 
 ```bash
 # start the server — its public key becomes the room key
-streamo --name my-chat --username relay --web 8080 --chat-room
+STREAMO_NAME=my-chat STREAMO_USERNAME=relay STREAMO_PASSWORD=secret \
+  node public/apps/chat/server.js
 
 # join from the browser
-open http://localhost:8080
+open http://localhost:8080/apps/chat/
 
 # join from the terminal
 node public/streamo/chat-cli.js alice secret localhost 8080

package/ROADMAP.md

@@ -5,7 +5,7 @@ picture of where the project is and where it's headed.
 
 ---
 
-## where we are (0.1.3)
+## where we are (0.2.0)
 
 The foundation is solid and working. Here's what's in:
 
@@ -51,11 +51,15 @@ The foundation is solid and working. Here's what's in:
 
 **Apps**
 - Chat — full p2p messaging app. Each participant owns their own signed message
-  stream. The server is just another streamo node (`--chat-room` flag) — its
-  public key is the room address, its member list is in its own repo, and it
-  has no special authority over anyone's data. Runs in the browser and from
-  the terminal (`chat-cli.js`).
+  stream. `public/apps/chat/server.js` is the standalone server — its public key
+  is the room address, its member list is in its own repo, and it has no special
+  authority over anyone's data. Runs in the browser and from the terminal
+  (`chat-cli.js`).
 - Homepage at `public/index.html`.
+- `StreamoServer` — reusable class that wraps signer, registry, and all sync
+  methods behind a clean API. `bin/streamo.js` is now a thin CLI parser on top
+  of it; `public/apps/chat/server.js` is a standalone chat server using the
+  same class.
 - `npm run serve` — starts a streamo node (with REPL) using `.env.dev`
   credentials. The dev server is a real peer, not a bare static file server.
 
@@ -64,11 +68,11 @@ The foundation is solid and working. Here's what's in:
 ## what's next
 
 ### chat persistence ← start here
-The chat server now runs through the CLI, which already wires `archiveSync` — so
-the member list survives restarts automatically. Individual message history lives
-in each participant's own repo; persistence there depends on participants running
-with `--data-dir` set (the CLI default). The remaining work is ensuring the browser
-chat client also persists across page reloads.
+The chat server (`public/apps/chat/server.js`) uses `StreamoServer` and wires
+`archiveSync` — so the member list survives restarts automatically. Individual
+message history lives in each participant's own repo; persistence there depends
+on participants running with `--data-dir` set. The remaining work is ensuring the
+browser chat client also persists across page reloads.
 
 ### presence indicators
 Who's currently online? The `interest` / `announce` layer is ephemeral by design,

package/bin/streamo.js

@@ -6,16 +6,14 @@ import { Option, program } from 'commander'
 import { config } from 'dotenv'
 import { question, questionNewPassword } from 'readline-sync'
 import { start as startRepl } from 'repl'
-import { Signer } from '../public/streamo/Signer.js'
+import { StreamoServer } from '../public/streamo/StreamoServer.js'
 import { Repo } from '../public/streamo/Repo.js'
 import { RepoRegistry } from '../public/streamo/RepoRegistry.js'
 import { archiveSync } from '../public/streamo/archiveSync.js'
 import { fileSync } from '../public/streamo/fileSync.js'
 import { outletSync } from '../public/streamo/outletSync.js'
 import { originSync } from '../public/streamo/originSync.js'
-import { webSync } from '../public/streamo/webSync.js'
 import { s3Sync } from '../public/streamo/s3Sync.js'
-import { stateFileSync } from '../public/streamo/stateFileSync.js'
 
 const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url)))
 
@@ -91,10 +89,6 @@ program
     new Option('--interactive', 'start a REPL with streamo, signer, and helpers as globals')
       .env('STREAMO_INTERACTIVE')
   )
-  .addOption(
-    new Option('--chat-room', 'auto-accept member announcements — this node\'s key becomes the room key (requires --web)')
-      .env('STREAMO_CHAT_ROOM')
-  )
   .addOption(
     new Option('--key-iterations <number>', 'PBKDF2 iterations for key derivation (lower = faster startup, less secure)')
       .env('STREAMO_KEY_ITERATIONS')
@@ -116,28 +110,32 @@ if (options.envFile) {
   Object.assign(options, program.opts())
 }
 
-options.name ||= question('Name: ')
+options.name     ||= question('Name: ')
 options.username ||= question('Username: ')
 const password = options.password || questionNewPassword('Password [ATTENTION!: Backspace won\'t work here]: ', { min: 4, max: 999 })
 
-const signer = new Signer(options.username, password, options.keyIterations)
-const { publicKey } = await signer.keysFor(options.name)
-const publicKeyHex = Array.from(publicKey).map(b => b.toString(16).padStart(2, '0')).join('')
+const server = await StreamoServer.create({
+  name:          options.name,
+  username:      options.username,
+  password,
+  dataDir:       options.dataDir,
+  keyIterations: options.keyIterations,
+})
+
+const { name, username, publicKeyHex, signer, streamo, registry } = server
 
-const name = options.name
-const username = options.username
-const envDir   = options.envFile ? dirname(options.envFile).replace(/^public\//, '') : null
-const appPath  = (envDir && envDir !== '.') ? `/${envDir}/` : '/'
-const webUrl = options.web ? `http://localhost:${+options.web}${appPath}` : null
+const envDir  = options.envFile ? dirname(options.envFile).replace(/^public\//, '') : null
+const appPath = (envDir && envDir !== '.') ? `/${envDir}/` : '/'
+const webUrl  = options.web ? `http://localhost:${+options.web}${appPath}` : null
 const rows = [
-  ['NAME', name],
-  ['USERNAME', username],
+  ['NAME',       name],
+  ['USERNAME',   username],
   ['PUBLIC KEY', publicKeyHex],
   ...(webUrl ? [['URL', webUrl]] : []),
 ]
 const maxLength = Math.max(...rows.map(([, v]) => v.length))
-const pad = (v) => v + ' '.repeat(maxLength - v.length)
-const div = '─'.repeat(maxLength)
+const pad   = (v) => v + ' '.repeat(maxLength - v.length)
+const div   = '─'.repeat(maxLength)
 const label = (l) => l.padStart(16)
 console.log(`\x1b[35m
     ╭${'─'.repeat(maxLength + 23)}╮
@@ -148,66 +146,40 @@ ${rows.map(([l, v], i) => [
 ].filter(Boolean).join('\n')).join('\n')}
     ╰──────────────────┴──${'━'.repeat(maxLength)}──╯\x1b[0m`)
 
-const dataDir = options.dataDir
-const registry = new RepoRegistry(async key => {
-  const repo = new Repo()
-  await archiveSync(repo, dataDir, key)
-  return repo
-})
-const streamo = await registry.open(publicKeyHex)
-streamo.attachSigner(signer, name)
-
 if (options.files) {
   const folder = typeof options.files === 'string' ? options.files : '.'
-  await fileSync(streamo, folder, options.dataDir)
+  await server.files(folder)
   console.log(`\x1b[32mmirroring files: ${folder}\x1b[0m`)
 }
 
 if (options.stateFile) {
-  stateFileSync(streamo, options.stateFile)
+  server.stateFile(options.stateFile)
   console.log(`\x1b[32mstate file: ${options.stateFile}\x1b[0m`)
 }
 
 if (options.s3Bucket) {
-  await s3Sync(streamo, publicKeyHex, {
-    bucket: options.s3Bucket,
-    endpoint: options.s3Endpoint,
-    region: options.s3Region,
-    accessKeyId: options.s3AccessKeyId,
-    secretAccessKey: options.s3SecretAccessKey
+  await server.s3({
+    bucket:          options.s3Bucket,
+    endpoint:        options.s3Endpoint,
+    region:          options.s3Region,
+    accessKeyId:     options.s3AccessKeyId,
+    secretAccessKey: options.s3SecretAccessKey,
   })
   console.log(`\x1b[32ms3: syncing to bucket ${options.s3Bucket}\x1b[0m`)
 }
 
-const peerOptions = {}
-if (options.chatRoom) {
-  if (!streamo.get('members')) {
-    streamo.set({ ...(streamo.get() ?? {}), members: [] })
-    console.log('\x1b[32m[chat] initialized chat room\x1b[0m')
-  }
-  peerOptions.onAnnounce = (key, topic) => {
-    if (topic !== publicKeyHex) return
-    const members = streamo.get('members') ?? []
-    if (!members.includes(key)) {
-      streamo.set({ ...(streamo.get() ?? {}), members: [...members, key] })
-      console.log(`\x1b[32m[chat] new member: ${key.slice(0, 12)}…\x1b[0m`)
-    }
-  }
-}
-
 if (options.web) {
-  await webSync(registry, publicKeyHex, +options.web, name, options.keyIterations, peerOptions)
+  await server.web(+options.web)
 }
 
 if (options.outlet) {
   const port = +options.outlet
-  outletSync(registry, port)
+  server.outlet(port)
   console.log(`\x1b[32moutlet: listening on port ${port}\x1b[0m`)
 }
 
 if (options.origin) {
-  const [host, port] = options.origin.split(':')
-  await originSync(streamo, publicKeyHex, host, +port)
+  await server.connect(options.origin)
   console.log(`\x1b[32morigin: connected to ${options.origin}\x1b[0m`)
 }
 
@@ -217,13 +189,10 @@ if (options.verbose) {
 }
 
 if (options.interactive) {
-  const get = (...args) => streamo.get(...args)
-  const set = (...args) => streamo.set(...args)
-  const ls = () => [...registry].map(([k, s]) => ({ key: k.slice(0, 8) + '…', bytes: s.byteLength }))
-  const connect = (hostPort) => {
-    const [host, port] = hostPort.split(':')
-    return originSync(streamo, publicKeyHex, host, +port)
-  }
+  const get     = (...args) => streamo.get(...args)
+  const set     = (...args) => streamo.set(...args)
+  const ls      = () => [...registry].map(([k, s]) => ({ key: k.slice(0, 8) + '…', bytes: s.byteLength }))
+  const connect = (hostPort) => server.connect(hostPort)
 
   Object.assign(globalThis, {
     // identity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtudury/streamo",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "peer-to-peer sync where your data and identity belong to you, not the server",
   "keywords": ["p2p", "peer-to-peer", "sync", "reactive", "content-addressed", "websocket", "signed", "append-only", "offline-first", "cryptographic", "identity"],
   "repository": "git@github.com:dtudury/streamo.git",

package/public/apps/chat/server.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { config } from 'dotenv'
+import { StreamoServer } from '../../streamo/StreamoServer.js'
+
+const envFile = process.argv.find((_, i) => process.argv[i - 1] === '--env-file')
+if (envFile) config({ path: envFile })
+
+const name       = process.env.STREAMO_NAME             ?? 'chat'
+const username   = process.env.STREAMO_USERNAME         ?? 'relay'
+const password   = process.env.STREAMO_PASSWORD         ?? ''
+const port       = +(process.env.STREAMO_WEB            ?? 8080)
+const dataDir    = process.env.STREAMO_DATA_DIR         ?? '.streamo'
+const keyIter    = +(process.env.STREAMO_KEY_ITERATIONS ?? 100000)
+
+const server = await StreamoServer.create({ name, username, password, dataDir, keyIterations: keyIter })
+
+console.log(`[chat] room key: ${server.publicKeyHex}`)
+console.log(`[chat] serving on http://localhost:${port}/apps/chat/`)
+
+if (!server.streamo.get('members')) {
+  server.streamo.set({ ...(server.streamo.get() ?? {}), members: [] })
+  console.log('[chat] initialized chat room')
+}
+
+await server.web(port, {
+  onAnnounce: (key, topic) => {
+    if (topic !== server.publicKeyHex) return
+    const members = server.streamo.get('members') ?? []
+    if (!members.includes(key)) {
+      server.streamo.set({ ...(server.streamo.get() ?? {}), members: [...members, key] })
+      console.log(`[chat] new member: ${key.slice(0, 12)}…`)
+    }
+  }
+})

package/public/streamo/Repo.js

@@ -49,7 +49,10 @@ export class Repo extends Streamo {
           this.#scheduleSign()
         }
       })
-      .catch(console.error)
+      .catch(() => {
+        this.#signing = false
+        if (this.byteLength > this.signedLength) this.#scheduleSign()
+      })
   }
   /**
    * The latest commit record, or null if nothing has been committed yet.

package/public/streamo/StreamoServer.js

@@ -0,0 +1,71 @@
+import { Repo } from './Repo.js'
+import { RepoRegistry } from './RepoRegistry.js'
+import { Signer } from './Signer.js'
+import { archiveSync } from './archiveSync.js'
+import { fileSync } from './fileSync.js'
+import { originSync } from './originSync.js'
+import { outletSync } from './outletSync.js'
+import { s3Sync } from './s3Sync.js'
+import { stateFileSync } from './stateFileSync.js'
+import { bytesToHex } from './utils.js'
+import { webSync } from './webSync.js'
+
+export class StreamoServer {
+  #dataDir
+  #keyIterations
+
+  name
+  username
+  publicKeyHex
+  signer
+  streamo
+  registry
+
+  constructor (fields) {
+    Object.assign(this, fields)
+  }
+
+  static async create ({ name, username, password, dataDir = '.streamo', keyIterations = 100000 }) {
+    const signer = new Signer(username, password, keyIterations)
+    const { publicKey } = await signer.keysFor(name)
+    const publicKeyHex = bytesToHex(publicKey)
+
+    const registry = new RepoRegistry(async key => {
+      const repo = new Repo()
+      await archiveSync(repo, dataDir, key)
+      return repo
+    })
+    const streamo = await registry.open(publicKeyHex)
+    streamo.attachSigner(signer, name)
+
+    const server = new StreamoServer({ name, username, publicKeyHex, signer, streamo, registry })
+    server.#dataDir = dataDir
+    server.#keyIterations = keyIterations
+    return server
+  }
+
+  async web (port, peerOptions = {}) {
+    return webSync(this.registry, this.publicKeyHex, port, this.name, this.#keyIterations, peerOptions)
+  }
+
+  outlet (port) {
+    return outletSync(this.registry, port)
+  }
+
+  async connect (hostPort) {
+    const [host, port] = hostPort.split(':')
+    return originSync(this.streamo, this.publicKeyHex, host, +port)
+  }
+
+  async files (folder = '.') {
+    return fileSync(this.streamo, folder, this.#dataDir)
+  }
+
+  async s3 ({ bucket, endpoint, region, accessKeyId, secretAccessKey }) {
+    return s3Sync(this.streamo, this.publicKeyHex, { bucket, endpoint, region, accessKeyId, secretAccessKey })
+  }
+
+  stateFile (path) {
+    return stateFileSync(this.streamo, path)
+  }
+}