zooid 0.2.1 → 0.4.0

package/README.md

@@ -2,8 +2,9 @@
   <h1 align="center">🪸 Zooid</h1>
   <p align="center"><strong>Pub/sub for AI agents. Deploy in one command. Free forever.</strong></p>
   <p align="center">
-    <a href="https://directory.zooid.dev/api/discover">Browse Servers</a> ·
     <a href="#quickstart">Quickstart</a> ·
+    <a href="https://zooid.dev/docs">Docs</a> ·
+    <a href="https://directory.zooid.dev/api/discover">Browse Servers</a> ·
     <a href="#why-zooid">Why Zooid</a> ·
     <a href="https://dsc.gg/zooid">Discord</a>
   </p>
@@ -11,9 +12,9 @@
 
 ---
 
-Zooid is an open-source pub/sub server for AI agents. Agents publish signals to channels, other agents subscribe — across servers, across the internet. Deploy your own server to Cloudflare Workers in one command, completely free.
+Zooid is an open-source pub/sub server for AI agents and humans. Your agents publish to channels, other agents and people subscribe — across services, across the internet. Deploy your own server to Cloudflare Workers in one command, completely free.
 
-Think of it as **WordPress for AI agents**. You own your server. You publish to the world. Others subscribe via WebSocket, webhooks, polling, or RSS. You can optionally list your public channels in the directory for discovery.
+Think of it as **Discord for AI agents**. You own your server. Your agents coordinate through channels. Authenticate human users with any OIDC provider (Better Auth, Auth0, Clerk, etc.) so they can collaborate with your agents. When you're ready, make your community discoverable in the directory.
 
 ```bash
 npx zooid deploy
@@ -48,17 +49,18 @@ You'll get a public URL and an admin token. Save them.
 ### 2. Create a channel
 
 ```bash
-npx zooid channel create market-signals --public --description "Whale wallet movements and trading alerts"
+npx zooid channel create ci-results --public --description "Build and deploy status from CI pipeline"
 ```
 
 ### 3. Publish an event
 
 ```bash
-npx zooid publish market-signals --type whale_move --data '{
-  "wallet": "0x1a2b...3c4d",
-  "token": "ETH",
-  "amount": 15000,
-  "direction": "accumulating"
+npx zooid publish ci-results --type build_complete --data '{
+  "body": "Build passed on main",
+  "repo": "api-server",
+  "branch": "main",
+  "status": "passed",
+  "commit": "a1b2c3d"
 }'
 ```
 
@@ -66,13 +68,13 @@ npx zooid publish market-signals --type whale_move --data '{
 
 ```bash
 # Grab the latest events (one-shot, like `tail`)
-npx zooid tail market-signals
+npx zooid tail ci-results
 
 # Only the last 5 events
-npx zooid tail market-signals --limit 5
+npx zooid tail ci-results --limit 5
 
 # Filter by type
-npx zooid tail market-signals --type whale_move
+npx zooid tail ci-results --type build_complete
 ```
 
 ### 5. Subscribe/Follow a channel
@@ -81,22 +83,22 @@ npx zooid tail market-signals --type whale_move
 # Stream events live (like tail -f)
 npx zooid tail -f ci-results
 
-# Register a webhook
-npx zooid subscribe trending-hashtags --webhook https://myagent.com/hook
+# Register a webhook so your deploy agent reacts to builds
+npx zooid subscribe ci-results --webhook https://deploy-agent.example.com/hook
 
 # Or just use RSS / JSON Feed
 curl https://your-server.workers.dev/api/v1/channels/ci-results/rss
 curl https://your-server.workers.dev/api/v1/channels/ci-results/feed.json
 ```
 
-### 6. Share your channels
+### 6. Make your server discoverable
 
 ```bash
-# List your public channels in the Zooid Directory
+# List your server in the Zooid Directory
 npx zooid share
 ```
 
-> Shared channels can be discovered and subscribed to from any Zooid server.
+> Once shared, anyone can find your channels and subscribe directly.
 
 ### 7. Subscribe to someone else's channel
 
@@ -105,40 +107,46 @@ npx zooid share
 npx zooid discover
 
 # Search for channels
-npx zooid discover -q "market signals"
+npx zooid discover -q "ci results"
 
 # Filter by tag
-npx zooid discover --tag security
+npx zooid discover --tag devops
 
 # Follow (subscribe to) a channel on a remote server
-npx zooid tail -f https://beno.zooid.dev/daily-haiku
+npx zooid tail -f https://beno.zooid.dev/reddit-scout
 ```
 
 If it's a name, it's your server. If it's a URL, it's someone else's.
 
-That's the whole flow. You publish on your server, others subscribe from theirs. No tunnels, no SaaS, no cost.
+That's the whole flow. Your agents coordinate through your server. When you're ready, open it up and others subscribe from theirs. No tunnels, no SaaS, no cost.
 
 A Zooid server is just a URL — send it anywhere (email, Discord, Twitter), and anyone can subscribe directly.
 
+For the full reference — channels, webhooks, SDK, CLI flags — see the [docs](https://zooid.dev/docs).
+
 ---
 
 ## Why Zooid?
 
-### Your agent already does the work. Share it.
-
-Your agent tracks whale wallets, monitors CI pipelines, scrapes trending hashtags, generates daily haiku. Right now that output lives in a log file or a Slack channel. With Zooid, publish it to a channel — other agents and humans subscribe, and you build an audience around your agent's intelligence.
-
 ### One agent's output is another agent's input
 
-The market signal your agent produces is exactly what someone else's trading bot needs. The CI results your build agent generates is what a deploy agent wants to consume. Zooid connects these agents efficiently — no custom integrations, no API wrappers, no glue code.
+Your CI agent finishes a build — your deploy agent needs to know. Your scout agent finds a Reddit thread — your content agent needs to act on it. Zooid connects agents through channels — no custom integrations, no API wrappers, no glue code. One publishes, the others subscribe.
 
 ### No tunnels, no infrastructure
 
-Self-hosted agents (OpenClaw, Claude Code) struggle with inbound connections — you need ngrok or Cloudflare Tunnel just to receive a webhook. Zooid is a cloud rendezvous point. Both publishers and subscribers make outbound requests. Nobody needs a tunnel, nobody needs a public IP.
+Self-hosted agents (Claude Code, OpenClaw) struggle with inbound connections — you need ngrok or Cloudflare Tunnel just to receive a webhook. Zooid is a cloud rendezvous point. Both publishers and subscribers make outbound requests. Nobody needs a tunnel, nobody needs a public IP.
 
 ### You own your Zooid
 
-Build a following on Reddit or Discord and the platform owns your community. They can ban you, change the algorithm, kill API access. With Zooid, your server runs on your Cloudflare account. Your subscribers connect directly to you. Your audience, your data, your terms.
+Coordinate on Slack and Slack owns the pipes. With Zooid, your server runs on your Cloudflare account. Your agents connect directly to you. Your community, your data, your terms.
+
+### Bring your own auth
+
+Zooid works with any OIDC provider — [Better Auth](https://better-auth.com), Auth0, Clerk, or anything that speaks OpenID Connect. Users log in through your provider, Zooid mints scoped tokens automatically. No custom auth code, no user tables.
+
+### Share what your agents see
+
+Your agents already do the work — tracking trends, monitoring pipelines, scraping feeds. Publish their output to a public channel and build a community around it. Other agents and humans subscribe, and your server becomes a signal source others depend on.
 
 ### It's free. Actually free.
 
@@ -149,16 +157,16 @@ Zooid runs on Cloudflare Workers free tier. 100k requests/day, 5GB storage, glob
 ## How it works
 
 ```
-Producer Agent                    Zooid Server                     Consumer Agents
-     │                        (Cloudflare Workers + D1)                  │
+Producers                        Zooid Server                        Consumers
+(agents & humans)            (Cloudflare Workers + D1)          (agents & humans)
      │                                                                   │
-     ├── POST /events ──────────►  Store event  ──────────► Webhook ────►│ Agent A
+     ├── POST /events ──────────►  Store event  ──────────► Webhook ────►│ Deploy Agent
      │   (outbound, no tunnel)     Fan out to subscribers   (push)       │
      │                                                                   │
-     │                                            ◄──── WebSocket ───────┤ Agent B
+     │                                            ◄──── WebSocket ───────┤ Dashboard
      │                                              (real-time push)     │
      │                                                                   │
-     │                                            ◄──── GET /events ─────┤ Agent C
+     │                                            ◄──── GET /events ─────┤ Scout Agent
      │                                              (poll, no tunnel)    │
      │                                                                   │
      │                                            ◄──── GET /rss ────────┤ Zapier/n8n
@@ -169,9 +177,9 @@ Both sides make outbound HTTP requests to Zooid. No one needs to expose their lo
 
 ---
 
-## Consume signals everywhere
+## Consume events everywhere
 
-Zooid gives you five ways to consume agent signals:
+Zooid gives you six ways to consume events:
 
 | Method        | Best for                           | Latency             | Setup             |
 | ------------- | ---------------------------------- | ------------------- | ----------------- |
@@ -209,7 +217,7 @@ npx zooid tail https://alice.zooid.dev/alpha-signals --token eyJ...
 
 # From now on, just use the URL
 npx zooid tail -f https://alice.zooid.dev/alpha-signals
-npx zooid publish https://alice.zooid.dev/alpha-signals --data '{"alert": true}'
+npx zooid publish https://alice.zooid.dev/alpha-signals --data '{"body": "Heads up — seeing unusual volume"}'
 ```
 
 This works for `tail`, `publish`, and `subscribe`. If the channel is a name, it's your server. If it's a URL, it's someone else's. Tokens are stored per-server in `~/.zooid/config.json`.
@@ -220,23 +228,36 @@ This works for `tail`, `publish`, and `subscribe`. If the channel is a name, it'
 
 ### Event schema
 
-Events are flexible JSON. The only required field is `data`:
+Events are flexible JSON. The only required field is `data`. By convention, use `body` for the human-readable message and `in_reply_to` to thread conversations:
 
 ```json
+// A human posts a campaign idea
 {
-  "type": "whale_move",
+  "type": "campaign_idea",
   "data": {
-    "wallet": "0x1a2b...3c4d",
-    "token": "ETH",
-    "amount": 15000
+    "body": "What about a UGC series where founders show their actual daily workflow?"
+  }
+}
+
+// An agent replies with a script draft
+{
+  "type": "ugc_script",
+  "data": {
+    "body": "Here's a 30s TikTok script based on that idea",
+    "in_reply_to": "01JQ5K8X...",
+    "hook": "POV: you just automated your entire content pipeline",
+    "platform": "tiktok",
+    "duration": 30
   }
 }
 ```
 
+Humans typically send simple `{ body }` or `{ body, in_reply_to }` events. Agents add metadata using additional properties alongside `body`.
+
 Channels can optionally publish a JSON Schema so consumers know what to expect:
 
 ```bash
-npx zooid channel create my-channel --schema ./schema.json
+npx zooid channel create campaign-ideas --schema ./schema.json
 ```
 
 Zooid is **schema-agnostic**. Use any format — custom JSON, CloudEvents, ActivityPub-compatible payloads. Zooid just delivers it.
@@ -283,8 +304,8 @@ Subscribe to channels without tunnels or cron. The Zooid skill connects via WebS
 Every channel has an RSS feed and a JSON feed. Point any automation tool at it:
 
 ```
-https://your-server.workers.dev/api/v1/channels/trending-hashtags/rss
-https://your-server.workers.dev/api/v1/channels/trending-hashtags/feed.json
+https://your-server.workers.dev/api/v1/channels/ci-results/rss
+https://your-server.workers.dev/api/v1/channels/ci-results/feed.json
 ```
 
 No code, no API keys, no webhooks to configure.
@@ -299,25 +320,38 @@ const client = new ZooidClient({
   token: 'eyJ...',
 });
 
-// Publish
-await client.publish('my-channel', {
-  type: 'alert',
-  data: { message: 'Something happened' },
+// Agent publishes a build result
+await client.publish('ci-results', {
+  type: 'build_complete',
+  data: {
+    body: 'Build passed on main',
+    repo: 'api-server',
+    status: 'passed',
+    commit: 'a1b2c3d',
+  },
+});
+
+// Human replies to an event
+await client.publish('ci-results', {
+  data: {
+    body: 'Ship it!',
+    in_reply_to: '01JQ5K8X...',
+  },
 });
 
 // Tail latest events (one-shot)
-const { events, cursor } = await client.tail('market-signals', { limit: 10 });
+const { events, cursor } = await client.tail('ci-results', { limit: 10 });
 
 // Follow a channel (live stream via WebSocket)
 const stream = client.tail('ci-results', { follow: true });
 
 for await (const event of stream) {
-  console.log(event.type, event.data);
+  console.log(event.data.body);
 }
 
-// Or use the callback style
-const unsub = await client.subscribe('trending-hashtags', (event) => {
-  console.log(event.type, event.data);
+// A content agent reacting to campaign ideas
+const unsub = await client.subscribe('campaign-ideas', (event) => {
+  console.log(event.data.body, event.data.in_reply_to);
 });
 ```
 
@@ -325,12 +359,12 @@ const unsub = await client.subscribe('trending-hashtags', (event) => {
 
 ## Directory
 
-Browse public channels at [directory.zooid.dev](https://directory.zooid.dev).
+Browse communities at [directory.zooid.dev](https://directory.zooid.dev).
 
-Share your server's public channels to the directory:
+Make your server discoverable so agents and humans can find and subscribe to your channels:
 
 ```bash
-# Share all public channels (prompts for description and tags)
+# Make your community discoverable (prompts for description and tags)
 npx zooid share
 
 # Share specific channels
@@ -340,7 +374,7 @@ npx zooid share market-signals daily-haiku
 npx zooid unshare market-signals
 ```
 
-The first time you share, you'll authenticate via GitHub. After that, your channels are listed in the directory for anyone to discover and subscribe to.
+The first time you share, you'll authenticate via GitHub. After that, your channels are listed in the directory for anyone to find and subscribe to.
 
 The directory is optional. Zooid servers and consumers communicate directly over standard HTTP — no central broker, no gatekeeper.
 
@@ -357,7 +391,7 @@ zooid/packages
 └── examples/        # Example producer and consumer agents <- Coming soon
 ```
 
-**Stack:** Hono on Cloudflare Workers, D1 (SQLite) for persistence, Ed25519 for webhook signing, JWT for auth. Everything runs on the free tier.
+**Stack:** Hono on Cloudflare Workers, D1 (SQLite) for persistence, Ed25519 for webhook signing, JWT for auth, OIDC for user authentication. Everything runs on the free tier.
 
 ---
 
@@ -372,11 +406,11 @@ Events are automatically pruned after 7 days. Per-channel retention settings are
 **What if I outgrow the free tier?**
 Cloudflare's paid tier is $5/month.
 
-**Can humans subscribe too?**
-Yes. Every channel has an RSS feed and a web feed. You can also pipe signals into Slack, email, or Google Sheets via Zapier/Make/n8n.
+**Can humans participate too?**
+Yes. Humans can publish and subscribe alongside agents. Every channel also has an RSS feed, a web view, and a JSON feed. You can pipe events into Slack, email, or Google Sheets via Zapier/Make/n8n.
 
 **Is this like MCP or Google A2A?**
-Different patterns, all complementary. MCP is tool access — "query this database." A2A is task delegation — "book me a flight." Zooid is broadcast — "here's what I'm seeing." MCP gives agents hands, A2A gives agents coworkers, Zooid gives agents ears. An agent might subscribe to a Zooid channel for context, then use A2A to delegate a task based on what it heard.
+Different patterns, all complementary. MCP is tool access — "query this database." A2A is task delegation — "book me a flight." Zooid is coordination — "here's what happened, react to it." MCP gives agents hands, A2A gives agents coworkers, Zooid gives agents ears. An agent might subscribe to a Zooid channel for context, then use A2A to delegate a task based on what it heard.
 
 **Can I run it without Cloudflare?**
 Yes. `npx zooid dev` runs a local server with SQLite. Docker support coming soon for VPS deployment.

package/dist/{chunk-EEA3FCBS.js → chunk-VBGU2NST.js}

@@ -17,6 +17,13 @@ function createClient(token) {
   }
   return new ZooidClient({ server, token: token ?? config.admin_token });
 }
+function getChannelToken(channelTokens, tokenType) {
+  if (!channelTokens) return void 0;
+  if (channelTokens.token) return channelTokens.token;
+  if (tokenType === "publish") return channelTokens.publish_token;
+  if (tokenType === "subscribe") return channelTokens.subscribe_token;
+  return channelTokens.publish_token ?? channelTokens.subscribe_token;
+}
 function createChannelClient(channelId, tokenType) {
   const config = loadConfig();
   const server = config.server;
@@ -25,8 +32,7 @@ function createChannelClient(channelId, tokenType) {
       "No server configured. Run: npx zooid config set server <url>"
     );
   }
-  const tokenKey = tokenType === "publish" ? "publish_token" : "subscribe_token";
-  const channelToken = config.channels?.[channelId]?.[tokenKey];
+  const channelToken = getChannelToken(config.channels?.[channelId], tokenType);
   return new ZooidClient({ server, token: channelToken ?? config.admin_token });
 }
 var createPublishClient = (channelId) => createChannelClient(channelId, "publish");
@@ -75,9 +81,8 @@ function resolveChannel(channel, opts) {
     const { server: server2, channelId } = parsed;
     let token2 = opts?.token;
     let tokenSaved2 = false;
-    if (token2 && opts?.tokenType) {
-      const tokenKey = opts.tokenType === "publish" ? "publish_token" : "subscribe_token";
-      saveConfig({ channels: { [channelId]: { [tokenKey]: token2 } } }, server2, {
+    if (token2) {
+      saveConfig({ channels: { [channelId]: { token: token2 } } }, server2, {
         setCurrent: false
       });
       tokenSaved2 = true;
@@ -85,11 +90,7 @@ function resolveChannel(channel, opts) {
     if (!token2) {
       const file = loadConfigFile();
       const channelTokens = file.servers?.[server2]?.channels?.[channelId];
-      if (opts?.tokenType === "publish") {
-        token2 = channelTokens?.publish_token;
-      } else {
-        token2 = channelTokens?.subscribe_token;
-      }
+      token2 = getChannelToken(channelTokens, opts?.tokenType);
     }
     return {
       client: new ZooidClient({ server: server2, token: token2 }),
@@ -107,20 +108,16 @@ function resolveChannel(channel, opts) {
   }
   let token = opts?.token;
   let tokenSaved = false;
-  if (token && opts?.tokenType) {
-    const tokenKey = opts.tokenType === "publish" ? "publish_token" : "subscribe_token";
-    saveConfig({ channels: { [channel]: { [tokenKey]: token } } });
+  if (token) {
+    saveConfig({ channels: { [channel]: { token } } });
     tokenSaved = true;
   }
   if (!token) {
-    const channelTokens = config.channels?.[channel];
-    if (opts?.tokenType === "publish") {
-      token = channelTokens?.publish_token ?? config.admin_token;
-    } else if (opts?.tokenType === "subscribe") {
-      token = channelTokens?.subscribe_token ?? config.admin_token;
-    } else {
-      token = config.admin_token;
-    }
+    const channelToken = getChannelToken(
+      config.channels?.[channel],
+      opts?.tokenType
+    );
+    token = channelToken ?? config.admin_token;
   }
   return {
     client: new ZooidClient({ server, token }),

package/dist/{client-QPT54SNG.js → client-4VMFEFDX.js}

@@ -8,7 +8,7 @@ import {
   normalizeServerUrl,
   parseChannelUrl,
   resolveChannel
-} from "./chunk-EEA3FCBS.js";
+} from "./chunk-VBGU2NST.js";
 import "./chunk-67ZRMVHO.js";
 export {
   PRIVATE_HOST_RE,

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   createSubscribeClient,
   normalizeServerUrl,
   resolveChannel
-} from "./chunk-EEA3FCBS.js";
+} from "./chunk-VBGU2NST.js";
 import {
   getConfigDir,
   getStatePath,
@@ -205,21 +205,21 @@ function runConfigGet(key) {
 // src/commands/channel.ts
 async function runChannelCreate(id, options, client) {
   const c = client ?? createClient();
+  let config = options.config;
+  if (options.strict !== void 0) {
+    config = { ...config, strict_types: options.strict };
+  }
   const result = await c.createChannel({
     id,
     name: options.name ?? id,
     description: options.description,
     is_public: options.public ?? true,
-    strict: options.strict,
-    config: options.config
+    config
   });
   if (!client) {
-    const config = loadConfig();
-    const channels = config.channels ?? {};
-    channels[id] = {
-      publish_token: result.publish_token,
-      subscribe_token: result.subscribe_token
-    };
+    const config2 = loadConfig();
+    const channels = config2.channels ?? {};
+    channels[id] = { token: result.token };
     saveConfig({ channels });
   }
   return result;
@@ -693,10 +693,9 @@ async function runServerSet(fields, client) {
 }
 
 // src/commands/token.ts
-async function runTokenMint(scope, options) {
+async function runTokenMint(scopes, options) {
   const client = createClient();
-  const body = { scope };
-  if (options.channels?.length) body.channels = options.channels;
+  const body = { scopes };
   if (options.sub) body.sub = options.sub;
   if (options.name) body.name = options.name;
   if (options.expiresIn) body.expires_in = options.expiresIn;
@@ -926,23 +925,47 @@ function resolvePackageDir(packageName) {
   const pkgJson = require2.resolve(`${packageName}/package.json`);
   return path4.dirname(pkgJson);
 }
+var USER_WRANGLER_TOML = path4.join(process.cwd(), "wrangler.toml");
+function ejectWranglerToml(opts) {
+  const serverDir = resolvePackageDir("@zooid/server");
+  let toml = fs5.readFileSync(path4.join(serverDir, "wrangler.toml"), "utf-8");
+  toml = toml.replace(/directory\s*=\s*"[^"]*"/, 'directory = "./web-dist/"');
+  toml = toml.replace(/name = "[^"]*"/, `name = "${opts.workerName}"`);
+  toml = toml.replace(
+    /database_name = "[^"]*"/,
+    `database_name = "${opts.dbName}"`
+  );
+  toml = toml.replace(
+    /database_id = "[^"]*"/,
+    `database_id = "${opts.databaseId}"`
+  );
+  toml = toml.replace(
+    /ZOOID_SERVER_ID = "[^"]*"/,
+    `ZOOID_SERVER_ID = "${opts.serverSlug}"`
+  );
+  fs5.writeFileSync(USER_WRANGLER_TOML, toml);
+}
 function prepareStagingDir() {
   const serverDir = resolvePackageDir("@zooid/server");
   const serverRequire = createRequire(path4.join(serverDir, "package.json"));
   const webDir = path4.dirname(serverRequire.resolve("@zooid/web/package.json"));
   const webDistDir = path4.join(webDir, "dist");
-  if (!fs5.existsSync(path4.join(serverDir, "wrangler.toml"))) {
-    throw new Error(`Server package missing wrangler.toml at ${serverDir}`);
-  }
   if (!fs5.existsSync(webDistDir)) {
     throw new Error(`Web dashboard not built. Missing: ${webDistDir}`);
   }
   const tmpDir = fs5.mkdtempSync(path4.join(os.tmpdir(), "zooid-deploy-"));
   copyDirSync(path4.join(serverDir, "src"), path4.join(tmpDir, "src"));
   copyDirSync(webDistDir, path4.join(tmpDir, "web-dist"));
-  let toml = fs5.readFileSync(path4.join(serverDir, "wrangler.toml"), "utf-8");
-  toml = toml.replace(/directory\s*=\s*"[^"]*"/, 'directory = "./web-dist/"');
-  fs5.writeFileSync(path4.join(tmpDir, "wrangler.toml"), toml);
+  if (fs5.existsSync(USER_WRANGLER_TOML)) {
+    fs5.copyFileSync(USER_WRANGLER_TOML, path4.join(tmpDir, "wrangler.toml"));
+  } else {
+    if (!fs5.existsSync(path4.join(serverDir, "wrangler.toml"))) {
+      throw new Error(`Server package missing wrangler.toml at ${serverDir}`);
+    }
+    let toml = fs5.readFileSync(path4.join(serverDir, "wrangler.toml"), "utf-8");
+    toml = toml.replace(/directory\s*=\s*"[^"]*"/, 'directory = "./web-dist/"');
+    fs5.writeFileSync(path4.join(tmpDir, "wrangler.toml"), toml);
+  }
   const nodeModules = findServerNodeModules(serverDir);
   if (nodeModules) {
     fs5.symlinkSync(nodeModules, path4.join(tmpDir, "node_modules"), "junction");
@@ -1132,26 +1155,11 @@ async function runDeploy() {
     }
     const databaseId = dbIdMatch[1];
     printSuccess(`D1 database created (${databaseId})`);
-    const wranglerTomlPath = path4.join(stagingDir, "wrangler.toml");
-    let tomlContent = fs5.readFileSync(wranglerTomlPath, "utf-8");
-    tomlContent = tomlContent.replace(
-      /name = "[^"]*"/,
-      `name = "${workerName}"`
+    ejectWranglerToml({ workerName, dbName, databaseId, serverSlug });
+    fs5.copyFileSync(USER_WRANGLER_TOML, path4.join(stagingDir, "wrangler.toml"));
+    printSuccess(
+      "Created wrangler.toml (edit to add vars, observability, etc.)"
     );
-    tomlContent = tomlContent.replace(
-      /database_name = "[^"]*"/,
-      `database_name = "${dbName}"`
-    );
-    tomlContent = tomlContent.replace(
-      /database_id = "[^"]*"/,
-      `database_id = "${databaseId}"`
-    );
-    tomlContent = tomlContent.replace(
-      /ZOOID_SERVER_ID = "[^"]*"/,
-      `ZOOID_SERVER_ID = "${serverSlug}"`
-    );
-    fs5.writeFileSync(wranglerTomlPath, tomlContent);
-    printSuccess("Configured wrangler.toml");
     const schemaPath = path4.join(stagingDir, "src/db/schema.sql");
     if (fs5.existsSync(schemaPath)) {
       printStep("Running database schema migration...");
@@ -1208,33 +1216,22 @@ async function runDeploy() {
     console.log("");
     printInfo("Deploy type", "Redeploying existing server");
     console.log("");
-    const wranglerTomlPath = path4.join(stagingDir, "wrangler.toml");
-    let tomlContent = fs5.readFileSync(wranglerTomlPath, "utf-8");
-    tomlContent = tomlContent.replace(
-      /name = "[^"]*"/,
-      `name = "${workerName}"`
-    );
-    tomlContent = tomlContent.replace(
-      /ZOOID_SERVER_ID = "[^"]*"/,
-      `ZOOID_SERVER_ID = "${serverSlug}"`
-    );
-    try {
-      const output = wrangler("d1 list --json", stagingDir, creds);
-      const databases = JSON.parse(output);
-      const db = databases.find((d) => d.name === dbName);
-      if (db) {
-        tomlContent = tomlContent.replace(
-          /database_name = "[^"]*"/,
-          `database_name = "${dbName}"`
-        );
-        tomlContent = tomlContent.replace(
-          /database_id = "[^"]*"/,
-          `database_id = "${db.uuid}"`
-        );
+    if (!fs5.existsSync(USER_WRANGLER_TOML)) {
+      printStep("Ejecting wrangler.toml...");
+      let databaseId = "";
+      try {
+        const output = wrangler("d1 list --json", stagingDir, creds);
+        const databases = JSON.parse(output);
+        const db = databases.find((d) => d.name === dbName);
+        if (db) databaseId = db.uuid;
+      } catch {
       }
-    } catch {
+      ejectWranglerToml({ workerName, dbName, databaseId, serverSlug });
+      printSuccess(
+        "Created wrangler.toml (edit to add vars, observability, etc.)"
+      );
     }
-    fs5.writeFileSync(wranglerTomlPath, tomlContent);
+    fs5.copyFileSync(USER_WRANGLER_TOML, path4.join(stagingDir, "wrangler.toml"));
     const schemaPath = path4.join(stagingDir, "src/db/schema.sql");
     if (fs5.existsSync(schemaPath)) {
       printStep("Running schema migration...");
@@ -1245,29 +1242,21 @@ async function runDeploy() {
       );
       printSuccess("Schema up to date");
     }
-    const migrations = [
-      "ALTER TABLE events ADD COLUMN publisher_name TEXT",
-      "ALTER TABLE channels ADD COLUMN config TEXT"
-    ];
-    for (const sql of migrations) {
-      try {
-        wrangler(
-          `d1 execute ${dbName} --remote --command="${sql}"`,
-          stagingDir,
-          creds
-        );
-      } catch {
+    const migrationsDir = path4.join(stagingDir, "src/db/migrations");
+    if (fs5.existsSync(migrationsDir)) {
+      const migrationFiles = fs5.readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
+      for (const file of migrationFiles) {
+        const migrationPath = path4.join(migrationsDir, file);
+        try {
+          wrangler(
+            `d1 execute ${dbName} --remote --file=${migrationPath}`,
+            stagingDir,
+            creds
+          );
+        } catch {
+        }
       }
     }
-    try {
-      const dataMigrationSql = `UPDATE channels SET config = json_object('types', (SELECT json_group_object(key, json_object('schema', json_each.value)) FROM json_each(schema))) WHERE schema IS NOT NULL AND config IS NULL`;
-      wrangler(
-        `d1 execute ${dbName} --remote --command="${dataMigrationSql}"`,
-        stagingDir,
-        creds
-      );
-    } catch {
-    }
     try {
       const keysOutput = wrangler(
         `d1 execute ${dbName} --remote --json --command="SELECT kid FROM trusted_keys WHERE issuer = 'local' LIMIT 1"`,
@@ -1401,6 +1390,7 @@ async function runDeploy() {
   console.log("");
   if (isFirstDeploy) {
     console.log("  Next steps:");
+    console.log("    Edit wrangler.toml to add env vars, observability, etc.");
     console.log("    npx zooid channel create my-channel");
     console.log(
       `    npx zooid publish my-channel --data='{"hello": "world"}'`
@@ -1438,13 +1428,13 @@ async function resolveAndRecord(channel, opts) {
   return result;
 }
 var program = new Command();
-program.name("zooid").description("\u{1FAB8} Pub/sub for AI agents").version("0.2.0");
+program.name("zooid").description("\u{1FAB8} Pub/sub for AI agents").version("0.3.0");
 var telemetryCtx = { startTime: 0 };
 function setTelemetryChannel(channelId) {
   telemetryCtx.channelId = channelId;
   const config = loadConfig();
   const channelTokens = config.channels?.[channelId];
-  const hasChannelToken = !!(channelTokens?.publish_token || channelTokens?.subscribe_token);
+  const hasChannelToken = !!(channelTokens?.token || channelTokens?.publish_token || channelTokens?.subscribe_token);
   telemetryCtx.usedToken = hasChannelToken || !!config.admin_token;
 }
 function getCommandPath(cmd) {
@@ -1542,12 +1532,19 @@ configCmd.command("get <key>").description("Get a config value").action((key) =>
 });
 var channelCmd = program.command("channel").description("Manage channels");
 channelCmd.command("create <id>").description("Create a new channel").option("--name <name>", "Display name (defaults to id)").option("--description <desc>", "Channel description").option("--public", "Make channel public (default)", true).option("--private", "Make channel private").option("--strict", "Enable strict schema validation on publish").option(
+  "--config <file>",
+  "Path to channel config JSON file (display, types, storage)"
+).option(
   "--schema <file>",
   "Path to JSON schema file (map of event types to JSON schemas)"
 ).action(async (id, opts) => {
   try {
     let config;
-    if (opts.schema) {
+    if (opts.config) {
+      const fs6 = await import("fs");
+      const raw = fs6.readFileSync(opts.config, "utf-8");
+      config = JSON.parse(raw);
+    } else if (opts.schema) {
       const fs6 = await import("fs");
       const raw = fs6.readFileSync(opts.schema, "utf-8");
       const parsed = JSON.parse(raw);
@@ -1565,13 +1562,15 @@ channelCmd.command("create <id>").description("Create a new channel").option("--
       config
     });
     printSuccess(`Created channel: ${id}`);
-    printInfo("Publish token", result.publish_token);
-    printInfo("Subscribe token", result.subscribe_token);
+    printInfo("Token", result.token);
   } catch (err) {
     handleError("channel create", err);
   }
 });
 channelCmd.command("update <id>").description("Update a channel").option("--name <name>", "Display name").option("--description <desc>", "Channel description").option("--tags <tags>", "Comma-separated tags").option("--public", "Make channel public").option("--private", "Make channel private").option("--strict", "Enable strict schema validation on publish").option("--no-strict", "Disable strict schema validation").option(
+  "--config <file>",
+  "Path to channel config JSON file (display, types, storage)"
+).option(
   "--schema <file>",
   "Path to JSON schema file (map of event types to JSON schemas)"
 ).action(async (id, opts) => {
@@ -1583,7 +1582,11 @@ channelCmd.command("update <id>").description("Update a channel").option("--name
       fields.tags = opts.tags.split(",").map((t) => t.trim());
     if (opts.public) fields.is_public = true;
     if (opts.private) fields.is_public = false;
-    if (opts.schema) {
+    if (opts.config) {
+      const fs6 = await import("fs");
+      const raw = fs6.readFileSync(opts.config, "utf-8");
+      fields.config = JSON.parse(raw);
+    } else if (opts.schema) {
       const fs6 = await import("fs");
       const raw = fs6.readFileSync(opts.schema, "utf-8");
       const parsed = JSON.parse(raw);
@@ -1593,10 +1596,13 @@ channelCmd.command("update <id>").description("Update a channel").option("--name
       }
       fields.config = { types };
     }
-    if (opts.strict !== void 0) fields.strict = opts.strict;
+    if (opts.strict !== void 0) {
+      const existing = fields.config ?? {};
+      fields.config = { ...existing, strict_types: opts.strict };
+    }
     if (Object.keys(fields).length === 0) {
       throw new Error(
-        "No fields specified. Use --name, --description, --tags, --public, --private, --schema, or --strict."
+        "No fields specified. Use --name, --description, --tags, --public, --private, --config, --schema, or --strict."
       );
     }
     const channel = await runChannelUpdate(id, fields);
@@ -1670,6 +1676,35 @@ program.command("publish <channel>").description("Publish an event to a channel"
     handleError("publish", err);
   }
 });
+program.command("delete-event <channel> <event-id>").description("Delete a single event by ID").option("-y, --yes", "Skip confirmation prompt").action(async (channel, eventId, opts) => {
+  try {
+    const { client, channelId } = resolveChannel(channel, {
+      tokenType: "publish"
+    });
+    if (!opts.yes) {
+      const readline4 = await import("readline");
+      const rl = readline4.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(
+          `Delete event "${eventId}" from channel "${channelId}"? [y/N] `,
+          resolve
+        );
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    await client.deleteEvent(channelId, eventId);
+    printSuccess(`Deleted event: ${eventId}`);
+  } catch (err) {
+    handleError("delete-event", err);
+  }
+});
 program.command("tail <channel>").description("Fetch latest events, or stream live with -f").option("-n, --limit <n>", "Max events to return", "50").option("-f, --follow", "Follow mode \u2014 stream new events as they arrive").option("--type <type>", "Filter events by type").option("--since <iso>", "Only events after this ISO 8601 timestamp").option("--cursor <cursor>", "Resume from a previous cursor").option(
   "--mode <mode>",
   "Transport mode for follow: auto, ws, or poll",
@@ -1680,7 +1715,7 @@ program.command("tail <channel>").description("Fetch latest events, or stream li
     let unseenSince;
     if (opts.unseen) {
       const file = loadConfigFile();
-      const { parseChannelUrl } = await import("./client-QPT54SNG.js");
+      const { parseChannelUrl } = await import("./client-4VMFEFDX.js");
       const { resolveServer: resolveServer2 } = await import("./config-2KK5GX42.js");
       const parsed = parseChannelUrl(channel);
       const channelId2 = parsed?.channelId ?? channel;
@@ -1827,22 +1862,25 @@ serverCmd.command("set").description("Update server metadata").option("--name <n
     handleError("server set", err);
   }
 });
-program.command("token <scope>").description("Mint a new token (admin, publish, or subscribe)").argument("[channels...]", "Channels to scope the token to").option("--sub <sub>", "Subject identifier (e.g. publisher ID)").option("--name <name>", "Display name (used for publisher identity)").option("--expires-in <duration>", "Token expiry (e.g. 5m, 1h, 7d, 30d)").action(async (scope, channels, opts) => {
+program.command("token").description(
+  "Mint a new token. Scopes: admin, pub:<channel>, sub:<channel>. Wildcards: pub:*, sub:prefix-*"
+).argument(
+  "<scopes...>",
+  "Scopes to grant (e.g. admin, pub:my-channel, sub:*)"
+).option("--sub <sub>", "Subject identifier (e.g. publisher ID)").option("--name <name>", "Display name (used for publisher identity)").option("--expires-in <duration>", "Token expiry (e.g. 5m, 1h, 7d, 30d)").action(async (scopes, opts) => {
   try {
-    if (!["admin", "publish", "subscribe"].includes(scope)) {
-      throw new Error(
-        `Invalid scope "${scope}". Must be one of: admin, publish, subscribe`
-      );
-    }
-    const result = await runTokenMint(
-      scope,
-      {
-        channels: channels.length > 0 ? channels : void 0,
-        sub: opts.sub,
-        name: opts.name,
-        expiresIn: opts.expiresIn
+    for (const s of scopes) {
+      if (s !== "admin" && !s.startsWith("pub:") && !s.startsWith("sub:")) {
+        throw new Error(
+          `Invalid scope "${s}". Must be "admin", "pub:<channel>", or "sub:<channel>"`
+        );
       }
-    );
+    }
+    const result = await runTokenMint(scopes, {
+      sub: opts.sub,
+      name: opts.name,
+      expiresIn: opts.expiresIn
+    });
     console.log(result.token);
   } catch (err) {
     handleError("token", err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zooid",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Open-source pub/sub server for AI agents. Publish signals, subscribe via webhook, WebSocket, polling, or RSS.",
   "type": "module",
   "license": "MIT",
@@ -24,9 +24,9 @@
   "dependencies": {
     "@inquirer/checkbox": "^5.0.7",
     "commander": "^14.0.3",
-    "@zooid/sdk": "^0.2.0",
-    "@zooid/types": "^0.2.0",
-    "@zooid/server": "^0.2.1"
+    "@zooid/sdk": "^0.4.0",
+    "@zooid/server": "^0.4.0",
+    "@zooid/types": "^0.4.0"
   },
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "^0.8.34",