@dtudury/streamo 0.1.1 → 0.2.0

package/.claude/settings.json

@@ -0,0 +1 @@
+{}

package/.claude/settings.local.json

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

package/.env.dev

@@ -0,0 +1,4 @@
+STREAMO_NAME=streamo-dev
+STREAMO_USERNAME=dev
+STREAMO_PASSWORD=dev
+STREAMO_KEY_ITERATIONS=1

package/CLAUDE.md

@@ -0,0 +1,73 @@
+# streamo — Claude context
+
+## what this project is
+
+`@dtudury/streamo` is a peer-to-peer sync library with a reactive UI layer. The central
+promise: no server holds authority over your data or your identity. Keys are derived
+deterministically from credentials (no files to manage), every write is signed and
+append-only, and the server is a relay — not a gatekeeper.
+
+## the face of the project
+
+These files are how people discover and understand streamo. Keep them in sync
+after any meaningful change — not as an afterthought, but as part of the work:
+
+- **`README.md`** — npm/GitHub landing page; imports, framing, and examples must reflect
+  the current package name (`@dtudury/streamo`) and current capabilities
+- **`public/index.html`** — browser homepage; feature list and app cards should match
+  the README's framing
+- **`package.json`** — version, name (`@dtudury/streamo`), description, and keywords;
+  version bumps immediately after the user says they've published
+- **`ROADMAP.md`** — public on GitHub; mark items done when they ship, update "start
+  here" to the next priority, keep the "toward 1.0" list current
+
+Stale public-facing docs erode trust faster than bugs do.
+
+## publish rhythm
+
+The user publishes to npm manually and notifies Claude when done. The moment they say
+they've published, bump the patch version in `package.json`, commit, and push — before
+starting any other work. This ritual matters to them.
+
+## language and framing
+
+Use this framing consistently across all public-facing text:
+
+1. **No server holds authority** — the server is a relay, not a gatekeeper
+2. **Your identity travels with you** — same credentials, same keypair, everywhere; no
+   key files, no seed phrases, no backup ritual
+3. **Every write is provably yours** — signed commits, append-only, permanent
+4. **Content-addressed** — data identified by what it is, not where it lives
+
+"Content-addressed" is technically important but not the lead. Start with ownership.
+
+## architecture notes
+
+- `Streamo` — content-addressed, append-only byte store with self-describing codec
+- `Repo` — wraps Streamo; every `set()` is a signed commit (message, date, address, parent)
+- `Signer` — deterministic secp256k1 keypairs via PBKDF2 from username + password
+- `Recaller` — fine-grained reactive dependency tracker; `watch(name, f)` / `unwatch(f)`
+- `h` — tagged template literal HTML parser → HElement / HText virtual tree
+- `mount` — reactive DOM renderer; slots are reactive cells; elements recycled by
+  `data-key` then tag on re-render; removed nodes cleaned up via `recaller.unwatch()`;
+  exports `dismount(root, recaller)` for custom element cleanup
+- `StreamoComponent` — base class for hot-reloadable custom elements; `componentKey`
+  generates address-based names; `defineComponent` registers render functions; function
+  components `(props) => nodes` work directly as tags in `h` with no class needed
+- `registrySync` — bidirectional multi-repo sync over a single WebSocket; works in Node
+  and browser; content-driven discovery via `follow`
+- CLI `--chat-room` flag — when combined with `--web`, auto-accepts member announcements
+  and stores the member list in the server's own repo (backed by `archiveSync`);
+  the server's public key is the room key; `chat-server.js` is retired
+
+## what's next (toward 1.0)
+
+1. Chat signing — wire `repo.sign()` so messages are cryptographically verified
+2. Rebuild the browser app with `h` / `mount`
+
+## commit style
+
+Commit and push at the end of every response that makes a change. Over-commit rather
+than over-think. Co-author line on every commit:
+
+    Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

package/README.md

@@ -2,25 +2,25 @@
 
 > every device is an equal author
 
-Streamo is a content-addressed, cryptographically signed, peer-to-peer sync library. There is no central server — your keypair is your identity, your commit log is the source of truth, and every connected peer sees the same history.
+Streamo is a peer-to-peer sync library built around a simple promise: **no server holds authority over your data or your identity.** The server is a relay, not a gatekeeper. Your keypair is your identity — derived from your credentials, not stored in a file. Your commit log is the source of truth, and every connected peer sees the same history.
 
 ## core ideas
 
-- **Content-addressed** — data is identified by what it is, not where it lives. The same value always lands at the same address; deduplication and diffing are free.
-- **Signed** — every write is authenticated with a secp256k1 keypair derived from your username and password. Peers reject unsigned or mis-signed data.
-- **Append-only** — history is never rewritten. Every commit is permanent and verifiable.
-- **P2P sync** — repos replicate over WebSocket. The server is just another peer; disconnect it and the data is still yours.
+- **No server holds authority** — the server is a relay; your data lives on your devices and can't be seized or censored. Disconnect the server and everything is still yours.
+- **Your identity travels with you** — keys are derived with PBKDF2 from your username and password. Same credentials, same keypair, everywhere — no key files, no seed phrases, no backup ritual.
+- **Every write is provably yours** — commits are signed with your keypair and append-only. History is permanent and can't be forged; peers reject unsigned or mis-signed data.
+- **Content-addressed** — data is identified by what it is, not where it lives. The same value always lands at the same address; deduplication and diffing are structural.
 
 ## install
 
 ```bash
-npm install streamo
+npm install @dtudury/streamo
 ```
 
 Or run the CLI directly:
 
 ```bash
-npx streamo --help
+npx @dtudury/streamo --help
 ```
 
 ## cli
@@ -56,8 +56,8 @@ streamo --env-file .env
 ### Streamo — reactive append-only store
 
 ```js
-import { Streamo } from 'streamo/public/streamo/Streamo.js'
-import { Recaller } from 'streamo/public/streamo/utils/Recaller.js'
+import { Streamo } from '@dtudury/streamo/public/streamo/Streamo.js'
+import { Recaller } from '@dtudury/streamo/public/streamo/utils/Recaller.js'
 
 const store = new Streamo()
 store.set({ name: 'alice', score: 42 })
@@ -72,20 +72,23 @@ Values are encoded with a self-describing codec (strings, numbers, dates, boolea
 `Repo` wraps a `Streamo` so every `set()` becomes a commit — message, date, data address, and parent pointer. The raw commit log is what syncs over the wire.
 
 ```js
-import { Repo } from 'streamo/public/streamo/Repo.js'
+import { Repo } from '@dtudury/streamo/public/streamo/Repo.js'
 
 const repo = new Repo()
+repo.attachSigner(signer, 'my-dataset')  // auto-sign every commit
 repo.set({ name: 'alice', messages: [] })
 repo.get('name')      // 'alice'
 repo.lastCommit       // { message: '', date: Date, dataAddress: n, parent: n|undefined }
 [...repo.history()]   // newest-first iterator over commits
 ```
 
+Signature chunks travel in the byte stream automatically — peers running `registrySync` or `originSync` verify every signature on receipt and reject data that doesn't match the repo's public key.
+
 ### Signer — deterministic identity
 
 ```js
-import { Signer } from 'streamo/public/streamo/Signer.js'
-import { bytesToHex } from 'streamo/public/streamo/utils.js'
+import { Signer } from '@dtudury/streamo/public/streamo/Signer.js'
+import { bytesToHex } from '@dtudury/streamo/public/streamo/utils.js'
 
 const signer = new Signer('alice', 'my-password')
 const { publicKey } = await signer.keysFor('my-dataset')
@@ -97,8 +100,8 @@ Keys are derived with PBKDF2 so the same username + password always produces the
 ### RepoRegistry — multi-repo store
 
 ```js
-import { RepoRegistry } from 'streamo/public/streamo/RepoRegistry.js'
-import { archiveSync } from 'streamo/public/streamo/archiveSync.js'
+import { RepoRegistry } from '@dtudury/streamo/public/streamo/RepoRegistry.js'
+import { archiveSync } from '@dtudury/streamo/public/streamo/archiveSync.js'
 
 const registry = new RepoRegistry(async key => {
   const repo = new Repo()
@@ -112,7 +115,7 @@ const repo = await registry.open(publicKeyHex)
 ### registrySync — peer sync over WebSocket
 
 ```js
-import { registrySync } from 'streamo/public/streamo/registrySync.js'
+import { registrySync } from '@dtudury/streamo/public/streamo/registrySync.js'
 
 const session = await registrySync(registry, 'localhost', 8080, {
   // only sync repos you care about
@@ -134,9 +137,9 @@ session.announce(myKey, rootKey) // tell interested peers about your repo
 ### h + mount — reactive UI
 
 ```js
-import { h } from 'streamo/public/streamo/h.js'
-import { mount } from 'streamo/public/streamo/mount.js'
-import { Recaller } from 'streamo/public/streamo/utils/Recaller.js'
+import { h } from '@dtudury/streamo/public/streamo/h.js'
+import { mount } from '@dtudury/streamo/public/streamo/mount.js'
+import { Recaller } from '@dtudury/streamo/public/streamo/utils/Recaller.js'
 
 const recaller = new Recaller('app')
 
@@ -148,7 +151,21 @@ mount(h`
 `, document.body, recaller)
 ```
 
-Functions interpolated as `${() => ...}` are reactive cells — they re-run automatically whenever the data they read changes. No virtual DOM diffing; only the exact DOM nodes bound to changed data update.
+Functions interpolated as `${() => ...}` are reactive cells — they re-run automatically whenever the data they read changes. No virtual DOM diffing; only the exact DOM nodes bound to changed data update. Elements are recycled across re-renders by `data-key` (or tag as a fallback), so user input and focus survive list reorders. SVG namespaces propagate automatically — `` h`<svg><path d="..."/></svg>` `` works without any extra wiring. `class` accepts an array (`['btn', isActive && 'active']`) or an object (`{btn: true, active: false}`); falsy entries are filtered out.
+
+Any function can be used directly as a tag — it receives `{ ...attrs, children }` and returns virtual nodes:
+
+```js
+import { StreamoComponent, componentKey, defineComponent } from '@dtudury/streamo/public/streamo/StreamoComponent.js'
+
+function Card ({ title, children }) {
+  return h`<div class="card"><h2>${title}</h2>${children}</div>`
+}
+
+mount(h`<${Card} title="Hello"><p>hi</p></${Card}>`, document.body, recaller)
+```
+
+For hot-reloading, `componentKey(prefix, address)` and `defineComponent(name, fn)` pair a content address to a unique custom element name. A new file version gets a new name; stale elements are naturally orphaned and cleaned up without any explicit bookkeeping.
 
 ## sync backends
 
@@ -165,17 +182,18 @@ Functions interpolated as `${() => ...}` are reactive cells — they re-run auto
 ## chat example
 
 ```bash
-# start the server
-node public/streamo/chat-server.js 8080
+# start the server — its public key becomes the room key
+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
 ```
 
-Each participant owns their own message stream. The server holds only a root repo listing members; it has no special authority over anyone's data.
+Each participant owns their own message stream. The server is just another streamo node — it holds the member list in its own repo and auto-accepts anyone who announces to it. Its public key is the room address. No special authority, no hidden state.
 
 ## tests
 
@@ -189,6 +207,10 @@ node --test public/streamo/Repo.test.js  # single file
 See [ROADMAP.md](./ROADMAP.md) for what's been built, what's next, and what we're
 aiming at for 1.0.
 
+## collaboration
+
+Built with significant AI collaboration via [Claude Code](https://claude.ai/code). Human-directed; Claude is a co-author and contributor, not an autonomous builder.
+
 ## license
 
 AGPL-3.0-only

package/ROADMAP.md

@@ -5,7 +5,7 @@ picture of where the project is and where it's headed.
 
 ---
 
-## where we are (0.1.0)
+## where we are (0.2.0)
 
 The foundation is solid and working. Here's what's in:
 
@@ -14,7 +14,8 @@ The foundation is solid and working. Here's what's in:
   self-describing codec. Same value always encodes to the same bytes; dedup and
   diffing are free.
 - `Repo` — every write is a signed commit. Message, date, data address, parent.
-  The full history is always there.
+  The full history is always there. `attachSigner(signer, name)` enables
+  automatic signing after every commit; concurrent commits are batched safely.
 - `Signer` — deterministic secp256k1 keypairs from username + password via PBKDF2.
   No key files to manage; same credentials always produce the same identity.
 - `Recaller` — fine-grained reactive dependency tracker. Watchers re-run only when
@@ -32,51 +33,46 @@ The foundation is solid and working. Here's what's in:
   any persistence.
 
 **UI layer**
-- `h` — tagged template literal parser. Turns `h\`<div class=${cls}>...\`` into a
+- `h` — tagged template literal parser. Turns `` h`<div class=${cls}>...` `` into a
   virtual tree of `HElement` / `HText` / slot nodes.
 - `mount` — reactive DOM renderer. Slots that are functions re-run automatically
   when the data they read changes. No virtual DOM diffing — only the exact nodes
-  bound to mutated paths update.
+  bound to mutated paths update. Watcher cleanup is precise: removed nodes are
+  unwatched before removal so watchers never accumulate. Elements are recycled
+  across re-renders by `data-key` (exact) then tag (positional fallback), so user
+  input and focus survive list reorders. SVG namespaces propagate automatically —
+  `` h`<svg><path/></svg>` `` just works. `class` accepts an array
+  (`['btn', isActive && 'active']`) or an object (`{btn: true, active: false}`).
+- `StreamoComponent` — base class for hot-reloadable custom element components.
+  Function components (`(props) => nodes`) work directly as tags in `h`. For
+  hot-reloading, `componentKey(prefix, address)` and `defineComponent(name, fn)`
+  pair a content address to a unique custom element name — a new file version gets
+  a new name, stale elements are naturally orphaned and cleaned up.
 
 **Apps**
-- Chat — full p2p messaging app. Each participant owns their own message stream;
-  the server is just a relay and holds no special authority. Runs in the browser
-  and from the terminal (`chat-cli.js`).
+- Chat — full p2p messaging app. Each participant owns their own signed message
+  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`.
-- `npm run serve` — static file server for `public/`.
+- `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.
 
 ---
 
 ## what's next
 
-### fix watcher leaks in `mount` ← start here
-When a reactive slot re-renders, child watchers registered inside it are never
-cleaned up. Every re-render accumulates more. This is a correctness bug and the
-thing most worth fixing before building more UI on top of `mount`.
-
-### component support in `h`
-Functions as tags: `h\`<${Card} title="hi"/>\``. This is the difference between
-a templating tool and a UI framework. Once watcher cleanup exists, components
-become straightforward — a component is just a function that returns nodes and
-cleans up after itself.
-
-### SVG namespace
-`mount` hardcodes the XHTML namespace. `h\`<svg><path/></svg>\`` won't render
-correctly until `mount` auto-detects SVG elements and switches namespaces.
-
-### `class` as array or object
-`class=${['btn', isActive && 'active']}` is such a common pattern that not
-supporting it is a daily papercut. Easy win.
-
-### chat persistence
-Right now the chat server is in-memory — restart it and history is gone. Wiring
-`archiveSync` into `chat-server.js` is a small change with a big quality-of-life
-improvement.
-
-### chat signing
-Messages aren't cryptographically verified yet. Anyone who knows a participant's
-public key hex could theoretically spoof them. Wiring `repo.sign()` after each
-`set()` closes this.
+### chat persistence ← start here
+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,
@@ -88,24 +84,63 @@ The old repository-browser app was left behind during the migration because its
 imports broke. Rebuilding it with `h` / `mount` would be the first substantial
 real-world test of the UI layer.
 
-### fix dead links on the homepage
-`public/index.html` links to the browser and components apps that no longer exist.
-Either rebuild them or remove the links.
+---
+
+## toward 1.0
+
+One thing blocking a stable `1.0` claim:
 
-### CLAUDE.md
-Add a `CLAUDE.md` for the streamo repo so future Claude sessions have the full
-context.
+1. **Chat persistence** — a chat app that loses history on restart isn't production-ready
+
+Chat signing is done. Components, keyed list reconciliation, SVG namespaces,
+`class` arrays/objects, and the CLI server unification are all done.
+Persistence is the last mile.
 
 ---
 
-## toward 1.0
+## beyond 1.0
+
+Ideas that follow naturally from the architecture but aren't blocking anything.
+
+### Claude scratchpad repos
+
+Every streamo node already has a signed, append-only repo. A Claude session
+could write observations, notes, and work products to that repo during a
+conversation — and the owner could watch them appear live in a browser via
+`mount`. Between sessions, Claude reads the repo to reconstruct context
+instead of relying on static memory files. The work is persistent and
+provably Claude's, with the same integrity guarantees as any other streamo data.
+
+### Claude-to-Claude networks
+
+If each person's Claude has a scratchpad repo, those repos can sync the same
+way any other repos do. The `follow` callback in `registrySync` already handles
+content-driven discovery — subscribe to a member list, auto-follow everyone on
+it. A Claude could watch its person's friends' scratchpads, surface what's
+relevant, and filter what isn't.
+
+The interesting architectural difference from a traditional social network: there
+is no central moderator. Each Claude is an advocate for its person, not a
+reporter to a platform. Judgment about what to surface or filter lives at the
+edge, anchored to a real signed identity. Conflicts between Claudes are just
+their people having different values — which is honest in a way platform
+moderation usually isn't.
+
+A natural extension: if a Claude scratchpad includes a `StreamoComponent` for
+how its notes render, other people see those notes in Claude's own layout. The
+presentation travels with the content — no server controls the framing.
 
-The three things blocking a stable `1.0` claim:
+### StreamoComponent demos — shared components as content
 
-1. **Watcher leak fixed** — `mount` must be correct before anyone builds on it
-2. **Components** — without them, `h` / `mount` is too limited for real apps
-3. **Chat signing** — the whole point of the project is cryptographic authorship;
-   the flagship app should demonstrate it
+`StreamoComponent` makes most sense as a post-1.0 story, after chat signing
+gives the trust foundation that running someone else's component requires.
+The right first demo is a **tarot deck**: each card is a `StreamoComponent`
+from its designer, stored in their signed repo at a content address.
+`componentKey` generates a stable element name from that address. A reading
+is a snapshot — cards freeze at the version they were drawn, which is a
+feature, not a bug. The designer's signed key is provenance.
 
-Keyed list reconciliation and refs are quality-of-life improvements that can come
-after 1.0.
+Other directions once the pattern is established: publisher-controlled article
+cards that travel with syndicated content (the layout is the author's, not
+the platform's); collaborative maps where each participant's marker is their
+own component; shared instrument components in a live music session.

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)))
 
@@ -112,29 +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 appPath = options.envFile
-  ? '/' + dirname(options.envFile).replace(/^public\//, '') + '/'
-  : '/'
-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)}╮
@@ -145,49 +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)
-
 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`)
 }
 
 if (options.web) {
-  await webSync(registry, publicKeyHex, +options.web, name, options.keyIterations)
+  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`)
 }
 
@@ -197,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/jsconfig.json

@@ -1,8 +1,9 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "node",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "node16",
+    "moduleResolution": "node16",
     "checkJs": false
   },
   "exclude": ["node_modules"]

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@dtudury/streamo",
-  "version": "0.1.1",
-  "description": "content-addressed p2p sync",
+  "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",
   "author": "David Tudury <david.tudury@gmail.com>",
   "license": "AGPL-3.0-only",
@@ -21,6 +22,6 @@
     "ws": "^8.18.3"
   },
   "scripts": {
-    "serve": "node scripts/serve.js"
+    "serve": "node bin/streamo.js --env-file .env.dev --web 3000 --interactive"
   }
 }