zooid 0.2.0 → 0.3.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>
@@ -120,6 +121,8 @@ That's the whole flow. You publish on your server, others subscribe from theirs.
 
 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?

package/dist/chunk-67ZRMVHO.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+// src/lib/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// src/lib/constants.ts
+var STATE_FILENAME = "state.json";
+var LEGACY_STATE_FILENAME = "config.json";
+
+// src/lib/config.ts
+function getConfigDir() {
+  return process.env.ZOOID_CONFIG_DIR ?? path.join(os.homedir(), ".zooid");
+}
+function getStatePath() {
+  const dir = getConfigDir();
+  const statePath = path.join(dir, STATE_FILENAME);
+  if (!fs.existsSync(statePath)) {
+    const legacyPath = path.join(dir, LEGACY_STATE_FILENAME);
+    if (fs.existsSync(legacyPath)) {
+      fs.renameSync(legacyPath, statePath);
+    }
+  }
+  return statePath;
+}
+var getConfigPath = getStatePath;
+function loadConfigFile() {
+  try {
+    const raw = fs.readFileSync(getStatePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.server && !parsed.servers) {
+      const serverUrl = parsed.server;
+      const migrated = {
+        current: serverUrl,
+        servers: {
+          [serverUrl]: {
+            worker_url: parsed.worker_url,
+            admin_token: parsed.admin_token,
+            channels: parsed.channels
+          }
+        }
+      };
+      const dir = getConfigDir();
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(
+        getConfigPath(),
+        JSON.stringify(migrated, null, 2) + "\n"
+      );
+      return migrated;
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+var serverNoteShown = false;
+function resolveServer() {
+  const file = loadConfigFile();
+  let cwdUrl;
+  try {
+    const zooidJsonPath = path.join(process.cwd(), "zooid.json");
+    if (fs.existsSync(zooidJsonPath)) {
+      const raw = fs.readFileSync(zooidJsonPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      cwdUrl = parsed.url || void 0;
+    }
+  } catch {
+  }
+  if (cwdUrl) {
+    if (file.current && file.current !== cwdUrl && !serverNoteShown) {
+      serverNoteShown = true;
+      console.log(
+        `  Note: using server from zooid.json (${cwdUrl}), current is ${file.current}`
+      );
+    }
+    return cwdUrl;
+  }
+  return file.current;
+}
+function loadConfig() {
+  const file = loadConfigFile();
+  const serverUrl = resolveServer();
+  const entry = serverUrl ? file.servers?.[serverUrl] : void 0;
+  return {
+    server: serverUrl,
+    worker_url: entry?.worker_url,
+    admin_token: entry?.admin_token,
+    channels: entry?.channels
+  };
+}
+function saveConfig(partial, serverUrl, options) {
+  const dir = getConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const file = loadConfigFile();
+  const url = serverUrl ?? resolveServer();
+  if (!url) {
+    throw new Error(
+      "No server URL to save config for. Deploy first or set url in zooid.json."
+    );
+  }
+  if (!file.servers) file.servers = {};
+  const existing = file.servers[url] ?? {};
+  const merged = { ...existing, ...partial };
+  if (partial.channels && existing.channels) {
+    merged.channels = { ...existing.channels };
+    for (const [chId, chData] of Object.entries(partial.channels)) {
+      merged.channels[chId] = { ...existing.channels[chId], ...chData };
+    }
+  }
+  file.servers[url] = merged;
+  if (options?.setCurrent !== false) {
+    file.current = url;
+  }
+  fs.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
+}
+function loadDirectoryToken() {
+  const file = loadConfigFile();
+  return file.directory_token;
+}
+function saveDirectoryToken(token) {
+  const dir = getConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const file = loadConfigFile();
+  file.directory_token = token;
+  fs.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
+}
+function recordTailHistory(channelId, serverUrl, name, lastEventId) {
+  const url = serverUrl ?? resolveServer();
+  if (!url) return;
+  const file = loadConfigFile();
+  if (!file.servers) file.servers = {};
+  if (!file.servers[url]) file.servers[url] = {};
+  if (!file.servers[url].channels) file.servers[url].channels = {};
+  const channel = file.servers[url].channels[channelId] ?? {};
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = channel.stats;
+  channel.stats = {
+    num_tails: (existing?.num_tails ?? 0) + 1,
+    last_tailed_at: now,
+    first_tailed_at: existing?.first_tailed_at ?? now,
+    last_event_id: lastEventId ?? existing?.last_event_id
+  };
+  if (name) {
+    channel.name = name;
+  }
+  file.servers[url].channels[channelId] = channel;
+  const dir = getConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
+}
+function switchServer(url) {
+  const dir = getConfigDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const file = loadConfigFile();
+  if (!file.servers) file.servers = {};
+  if (!file.servers[url]) file.servers[url] = {};
+  file.current = url;
+  fs.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
+}
+
+export {
+  getConfigDir,
+  getStatePath,
+  getConfigPath,
+  loadConfigFile,
+  resolveServer,
+  loadConfig,
+  saveConfig,
+  loadDirectoryToken,
+  saveDirectoryToken,
+  recordTailHistory,
+  switchServer
+};

package/dist/chunk-VBGU2NST.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import {
+  loadConfig,
+  loadConfigFile,
+  saveConfig
+} from "./chunk-67ZRMVHO.js";
+
+// src/lib/client.ts
+import { ZooidClient } from "@zooid/sdk";
+function createClient(token) {
+  const config = loadConfig();
+  const server = config.server;
+  if (!server) {
+    throw new Error(
+      "No server configured. Run: npx zooid config set server <url>"
+    );
+  }
+  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;
+  if (!server) {
+    throw new Error(
+      "No server configured. Run: npx zooid config set server <url>"
+    );
+  }
+  const channelToken = getChannelToken(config.channels?.[channelId], tokenType);
+  return new ZooidClient({ server, token: channelToken ?? config.admin_token });
+}
+var createPublishClient = (channelId) => createChannelClient(channelId, "publish");
+var createSubscribeClient = (channelId) => createChannelClient(channelId, "subscribe");
+var PRIVATE_HOST_RE = /^(localhost|127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+)$/;
+function normalizeServerUrl(url) {
+  let normalized = url.replace(/\/+$/, "");
+  try {
+    const parsed = new URL(normalized);
+    if (parsed.protocol === "http:" && !PRIVATE_HOST_RE.test(parsed.hostname)) {
+      normalized = normalized.replace(/^http:\/\//, "https://");
+    }
+  } catch {
+  }
+  return normalized;
+}
+function parseChannelUrl(channel) {
+  let raw = channel;
+  if (!raw.startsWith("http") && raw.includes("/")) {
+    if (PRIVATE_HOST_RE.test(raw.split(/[:/]/)[0])) {
+      raw = `http://${raw}`;
+    } else if (raw.includes(".")) {
+      raw = `https://${raw}`;
+    } else if (/^[^/]+:\d+\//.test(raw)) {
+      raw = `http://${raw}`;
+    }
+  }
+  if (!raw.startsWith("http")) return null;
+  try {
+    const url = new URL(raw);
+    const channelsMatch = url.pathname.match(/^\/channels\/([^/]+)/);
+    if (channelsMatch) {
+      return { server: url.origin, channelId: channelsMatch[1] };
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length === 1) {
+      return { server: url.origin, channelId: segments[0] };
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveChannel(channel, opts) {
+  const parsed = parseChannelUrl(channel);
+  if (parsed) {
+    const { server: server2, channelId } = parsed;
+    let token2 = opts?.token;
+    let tokenSaved2 = false;
+    if (token2) {
+      saveConfig({ channels: { [channelId]: { token: token2 } } }, server2, {
+        setCurrent: false
+      });
+      tokenSaved2 = true;
+    }
+    if (!token2) {
+      const file = loadConfigFile();
+      const channelTokens = file.servers?.[server2]?.channels?.[channelId];
+      token2 = getChannelToken(channelTokens, opts?.tokenType);
+    }
+    return {
+      client: new ZooidClient({ server: server2, token: token2 }),
+      channelId,
+      server: server2,
+      tokenSaved: tokenSaved2
+    };
+  }
+  const config = loadConfig();
+  const server = config.server;
+  if (!server) {
+    throw new Error(
+      "No server configured. Run: npx zooid config set server <url>"
+    );
+  }
+  let token = opts?.token;
+  let tokenSaved = false;
+  if (token) {
+    saveConfig({ channels: { [channel]: { token } } });
+    tokenSaved = true;
+  }
+  if (!token) {
+    const channelToken = getChannelToken(
+      config.channels?.[channel],
+      opts?.tokenType
+    );
+    token = channelToken ?? config.admin_token;
+  }
+  return {
+    client: new ZooidClient({ server, token }),
+    channelId: channel,
+    server,
+    tokenSaved
+  };
+}
+
+export {
+  createClient,
+  createChannelClient,
+  createPublishClient,
+  createSubscribeClient,
+  PRIVATE_HOST_RE,
+  normalizeServerUrl,
+  parseChannelUrl,
+  resolveChannel
+};

package/dist/client-4VMFEFDX.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import {
+  PRIVATE_HOST_RE,
+  createChannelClient,
+  createClient,
+  createPublishClient,
+  createSubscribeClient,
+  normalizeServerUrl,
+  parseChannelUrl,
+  resolveChannel
+} from "./chunk-VBGU2NST.js";
+import "./chunk-67ZRMVHO.js";
+export {
+  PRIVATE_HOST_RE,
+  createChannelClient,
+  createClient,
+  createPublishClient,
+  createSubscribeClient,
+  normalizeServerUrl,
+  parseChannelUrl,
+  resolveChannel
+};

package/dist/config-2KK5GX42.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import {
+  getConfigDir,
+  getConfigPath,
+  getStatePath,
+  loadConfig,
+  loadConfigFile,
+  loadDirectoryToken,
+  recordTailHistory,
+  resolveServer,
+  saveConfig,
+  saveDirectoryToken,
+  switchServer
+} from "./chunk-67ZRMVHO.js";
+export {
+  getConfigDir,
+  getConfigPath,
+  getStatePath,
+  loadConfig,
+  loadConfigFile,
+  loadDirectoryToken,
+  recordTailHistory,
+  resolveServer,
+  saveConfig,
+  saveDirectoryToken,
+  switchServer
+};

package/dist/index.js

@@ -1,162 +1,34 @@
 #!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+import {
+  createClient,
+  createPublishClient,
+  createSubscribeClient,
+  normalizeServerUrl,
+  resolveChannel
+} from "./chunk-VBGU2NST.js";
+import {
+  getConfigDir,
+  getStatePath,
+  loadConfig,
+  loadConfigFile,
+  loadDirectoryToken,
+  recordTailHistory,
+  resolveServer,
+  saveConfig,
+  saveDirectoryToken,
+  switchServer
+} from "./chunk-67ZRMVHO.js";
 
 // src/index.ts
 import { Command } from "commander";
 
-// src/lib/config.ts
+// src/lib/telemetry.ts
 import fs from "fs";
-import os from "os";
 import path from "path";
-function getConfigDir() {
-  return process.env.ZOOID_CONFIG_DIR ?? path.join(os.homedir(), ".zooid");
-}
-function getConfigPath() {
-  return path.join(getConfigDir(), "config.json");
-}
-function loadConfigFile() {
-  try {
-    const raw = fs.readFileSync(getConfigPath(), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed.server && !parsed.servers) {
-      const serverUrl = parsed.server;
-      const migrated = {
-        current: serverUrl,
-        servers: {
-          [serverUrl]: {
-            worker_url: parsed.worker_url,
-            admin_token: parsed.admin_token,
-            channels: parsed.channels
-          }
-        }
-      };
-      const dir = getConfigDir();
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(
-        getConfigPath(),
-        JSON.stringify(migrated, null, 2) + "\n"
-      );
-      return migrated;
-    }
-    return parsed;
-  } catch {
-    return {};
-  }
-}
-function resolveServer() {
-  const file = loadConfigFile();
-  let cwdUrl;
-  try {
-    const zooidJsonPath = path.join(process.cwd(), "zooid.json");
-    if (fs.existsSync(zooidJsonPath)) {
-      const raw = fs.readFileSync(zooidJsonPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      cwdUrl = parsed.url || void 0;
-    }
-  } catch {
-  }
-  if (cwdUrl) {
-    if (file.current && file.current !== cwdUrl) {
-      console.log(
-        `  Note: using server from zooid.json (${cwdUrl}), current is ${file.current}`
-      );
-    }
-    return cwdUrl;
-  }
-  return file.current;
-}
-function loadConfig() {
-  const file = loadConfigFile();
-  const serverUrl = resolveServer();
-  const entry = serverUrl ? file.servers?.[serverUrl] : void 0;
-  return {
-    server: serverUrl,
-    worker_url: entry?.worker_url,
-    admin_token: entry?.admin_token,
-    channels: entry?.channels
-  };
-}
-function saveConfig(partial, serverUrl, options) {
-  const dir = getConfigDir();
-  fs.mkdirSync(dir, { recursive: true });
-  const file = loadConfigFile();
-  const url = serverUrl ?? resolveServer();
-  if (!url) {
-    throw new Error(
-      "No server URL to save config for. Deploy first or set url in zooid.json."
-    );
-  }
-  if (!file.servers) file.servers = {};
-  const existing = file.servers[url] ?? {};
-  const merged = { ...existing, ...partial };
-  if (partial.channels && existing.channels) {
-    merged.channels = { ...existing.channels };
-    for (const [chId, chData] of Object.entries(partial.channels)) {
-      merged.channels[chId] = { ...existing.channels[chId], ...chData };
-    }
-  }
-  file.servers[url] = merged;
-  if (options?.setCurrent !== false) {
-    file.current = url;
-  }
-  fs.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
-}
-function loadDirectoryToken() {
-  const file = loadConfigFile();
-  return file.directory_token;
-}
-function saveDirectoryToken(token) {
-  const dir = getConfigDir();
-  fs.mkdirSync(dir, { recursive: true });
-  const file = loadConfigFile();
-  file.directory_token = token;
-  fs.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
-}
-function recordTailHistory(channelId, serverUrl, name) {
-  const url = serverUrl ?? resolveServer();
-  if (!url) return;
-  const file = loadConfigFile();
-  if (!file.servers) file.servers = {};
-  if (!file.servers[url]) file.servers[url] = {};
-  if (!file.servers[url].channels) file.servers[url].channels = {};
-  const channel = file.servers[url].channels[channelId] ?? {};
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const existing = channel.stats;
-  channel.stats = {
-    num_tails: (existing?.num_tails ?? 0) + 1,
-    last_tailed_at: now,
-    first_tailed_at: existing?.first_tailed_at ?? now
-  };
-  if (name) {
-    channel.name = name;
-  }
-  file.servers[url].channels[channelId] = channel;
-  const dir = getConfigDir();
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
-}
-function switchServer(url) {
-  const dir = getConfigDir();
-  fs.mkdirSync(dir, { recursive: true });
-  const file = loadConfigFile();
-  if (!file.servers) file.servers = {};
-  if (!file.servers[url]) file.servers[url] = {};
-  file.current = url;
-  fs.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
-}
-
-// src/lib/telemetry.ts
-import fs2 from "fs";
-import path2 from "path";
 import { randomUUID } from "crypto";
+import { spawn } from "child_process";
 var TELEMETRY_ENDPOINT = "https://telemetry.zooid.dev/v1/events";
 var QUEUE_FILENAME = "telemetry.json";
-var CONFIG_FILENAME = "config.json";
 var MAX_QUEUE_SIZE = 1e3;
 function isEnabled() {
   const envVar = process.env.ZOOID_TELEMETRY;
@@ -185,10 +57,10 @@ function writeEvent(event) {
   const queuePath = getQueuePath();
   const dir = getConfigDir();
   try {
-    fs2.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(dir, { recursive: true });
     let queue = [];
     try {
-      const raw = fs2.readFileSync(queuePath, "utf-8");
+      const raw = fs.readFileSync(queuePath, "utf-8");
       queue = JSON.parse(raw);
     } catch {
     }
@@ -196,22 +68,21 @@ function writeEvent(event) {
     if (queue.length > MAX_QUEUE_SIZE) {
       queue = queue.slice(-MAX_QUEUE_SIZE);
     }
-    fs2.writeFileSync(queuePath, JSON.stringify(queue, null, 2) + "\n");
+    fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2) + "\n");
   } catch {
   }
 }
 function flushInBackground() {
   const queuePath = getQueuePath();
   try {
-    const raw = fs2.readFileSync(queuePath, "utf-8");
+    const raw = fs.readFileSync(queuePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed) || parsed.length === 0) return;
   } catch {
     return;
   }
   try {
-    const { spawn: spawn2 } = __require("child_process");
-    const child = spawn2(process.execPath, ["-e", flushScript(queuePath)], {
+    const child = spawn(process.execPath, ["-e", flushScript(queuePath)], {
       detached: true,
       stdio: "ignore",
       env: { ...process.env }
@@ -221,9 +92,9 @@ function flushInBackground() {
   }
 }
 function getInstallId() {
-  const configPath = path2.join(getConfigDir(), CONFIG_FILENAME);
+  const configPath = getStatePath();
   try {
-    const raw = fs2.readFileSync(configPath, "utf-8");
+    const raw = fs.readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.install_id) return parsed.install_id;
   } catch {
@@ -233,12 +104,12 @@ function getInstallId() {
   return id;
 }
 function getQueuePath() {
-  return path2.join(getConfigDir(), QUEUE_FILENAME);
+  return path.join(getConfigDir(), QUEUE_FILENAME);
 }
 function readTelemetryFlag() {
-  const configPath = path2.join(getConfigDir(), CONFIG_FILENAME);
+  const configPath = getStatePath();
   try {
-    const raw = fs2.readFileSync(configPath, "utf-8");
+    const raw = fs.readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.telemetry === true) return true;
     if (parsed.telemetry === false) return false;
@@ -252,17 +123,17 @@ function writeTelemetryFlag(enabled) {
 }
 function persistToConfig(key, value) {
   const dir = getConfigDir();
-  const configPath = path2.join(dir, CONFIG_FILENAME);
+  const configPath = getStatePath();
   try {
-    fs2.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(dir, { recursive: true });
     let config = {};
     try {
-      const raw = fs2.readFileSync(configPath, "utf-8");
+      const raw = fs.readFileSync(configPath, "utf-8");
       config = JSON.parse(raw);
     } catch {
     }
     config[key] = value;
-    fs2.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
   } catch {
   }
 }
@@ -331,131 +202,6 @@ function runConfigGet(key) {
   );
 }
 
-// src/lib/client.ts
-import { ZooidClient } from "@zooid/sdk";
-function createClient(token) {
-  const config = loadConfig();
-  const server = config.server;
-  if (!server) {
-    throw new Error(
-      "No server configured. Run: npx zooid config set server <url>"
-    );
-  }
-  return new ZooidClient({ server, token: token ?? config.admin_token });
-}
-function createChannelClient(channelId, tokenType) {
-  const config = loadConfig();
-  const server = config.server;
-  if (!server) {
-    throw new Error(
-      "No server configured. Run: npx zooid config set server <url>"
-    );
-  }
-  const tokenKey = tokenType === "publish" ? "publish_token" : "subscribe_token";
-  const channelToken = config.channels?.[channelId]?.[tokenKey];
-  return new ZooidClient({ server, token: channelToken ?? config.admin_token });
-}
-var createPublishClient = (channelId) => createChannelClient(channelId, "publish");
-var createSubscribeClient = (channelId) => createChannelClient(channelId, "subscribe");
-var PRIVATE_HOST_RE = /^(localhost|127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+)$/;
-function normalizeServerUrl(url) {
-  let normalized = url.replace(/\/+$/, "");
-  try {
-    const parsed = new URL(normalized);
-    if (parsed.protocol === "http:" && !PRIVATE_HOST_RE.test(parsed.hostname)) {
-      normalized = normalized.replace(/^http:\/\//, "https://");
-    }
-  } catch {
-  }
-  return normalized;
-}
-function parseChannelUrl(channel) {
-  let raw = channel;
-  if (!raw.startsWith("http") && raw.includes("/")) {
-    if (PRIVATE_HOST_RE.test(raw.split(/[:/]/)[0])) {
-      raw = `http://${raw}`;
-    } else if (raw.includes(".")) {
-      raw = `https://${raw}`;
-    } else if (/^[^/]+:\d+\//.test(raw)) {
-      raw = `http://${raw}`;
-    }
-  }
-  if (!raw.startsWith("http")) return null;
-  try {
-    const url = new URL(raw);
-    const channelsMatch = url.pathname.match(/^\/channels\/([^/]+)/);
-    if (channelsMatch) {
-      return { server: url.origin, channelId: channelsMatch[1] };
-    }
-    const segments = url.pathname.split("/").filter(Boolean);
-    if (segments.length === 1) {
-      return { server: url.origin, channelId: segments[0] };
-    }
-  } catch {
-  }
-  return null;
-}
-function resolveChannel(channel, opts) {
-  const parsed = parseChannelUrl(channel);
-  if (parsed) {
-    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, {
-        setCurrent: false
-      });
-      tokenSaved2 = true;
-    }
-    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;
-      }
-    }
-    return {
-      client: new ZooidClient({ server: server2, token: token2 }),
-      channelId,
-      server: server2,
-      tokenSaved: tokenSaved2
-    };
-  }
-  const config = loadConfig();
-  const server = config.server;
-  if (!server) {
-    throw new Error(
-      "No server configured. Run: npx zooid config set server <url>"
-    );
-  }
-  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 } } });
-    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;
-    }
-  }
-  return {
-    client: new ZooidClient({ server, token }),
-    channelId: channel,
-    server,
-    tokenSaved
-  };
-}
-
 // src/commands/channel.ts
 async function runChannelCreate(id, options, client) {
   const c = client ?? createClient();
@@ -470,10 +216,7 @@ async function runChannelCreate(id, options, client) {
   if (!client) {
     const config = loadConfig();
     const channels = config.channels ?? {};
-    channels[id] = {
-      publish_token: result.publish_token,
-      subscribe_token: result.subscribe_token
-    };
+    channels[id] = { token: result.token };
     saveConfig({ channels });
   }
   return result;
@@ -494,20 +237,20 @@ async function runChannelDelete(channelId, client) {
     const serverUrl = resolveServer();
     if (serverUrl && file.servers?.[serverUrl]?.channels?.[channelId]) {
       delete file.servers[serverUrl].channels[channelId];
-      const fs7 = await import("fs");
-      fs7.writeFileSync(getConfigPath(), JSON.stringify(file, null, 2) + "\n");
+      const fs6 = await import("fs");
+      fs6.writeFileSync(getStatePath(), JSON.stringify(file, null, 2) + "\n");
     }
   }
 }
 
 // src/commands/publish.ts
-import fs3 from "fs";
+import fs2 from "fs";
 async function runPublish(channelId, options, client) {
   const c = client ?? createPublishClient(channelId);
   let type;
   let data;
   if (options.file) {
-    const raw = fs3.readFileSync(options.file, "utf-8");
+    const raw = fs2.readFileSync(options.file, "utf-8");
     const parsed = JSON.parse(raw);
     type = parsed.type;
     data = parsed.data ?? parsed;
@@ -708,13 +451,13 @@ async function deviceAuth() {
     "Authorization timed out. You need your human to authorize you. Run `npx zooid share` again to retry."
   );
 }
-async function directoryFetch(path6, options = {}) {
+async function directoryFetch(path5, options = {}) {
   let token = await ensureDirectoryToken();
   const doFetch = (t) => {
     const headers = new Headers(options.headers);
     headers.set("Authorization", `Bearer ${t}`);
     headers.set("Content-Type", "application/json");
-    return fetch(`${DIRECTORY_BASE_URL}${path6}`, { ...options, headers });
+    return fetch(`${DIRECTORY_BASE_URL}${path5}`, { ...options, headers });
   };
   let res = await doFetch(token);
   if (res.status === 401) {
@@ -947,10 +690,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;
@@ -958,10 +700,10 @@ async function runTokenMint(scope, options) {
 }
 
 // src/commands/dev.ts
-import { execSync, spawn } from "child_process";
+import { execSync, spawn as spawn2 } from "child_process";
 import crypto2 from "crypto";
-import fs4 from "fs";
-import path3 from "path";
+import fs3 from "fs";
+import path2 from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/crypto.ts
@@ -1027,25 +769,25 @@ async function createEdDSAAdminToken(privateKeyJwk, kid) {
 
 // src/commands/dev.ts
 function findServerDir() {
-  const cliDir = path3.dirname(fileURLToPath(import.meta.url));
-  return path3.resolve(cliDir, "../../server");
+  const cliDir = path2.dirname(fileURLToPath(import.meta.url));
+  return path2.resolve(cliDir, "../../server");
 }
 async function runDev(port = 8787) {
   const serverDir = findServerDir();
-  if (!fs4.existsSync(path3.join(serverDir, "wrangler.toml"))) {
+  if (!fs3.existsSync(path2.join(serverDir, "wrangler.toml"))) {
     throw new Error(
       `Server directory not found at ${serverDir}. Make sure you're running from the zooid monorepo.`
     );
   }
   const jwtSecret = crypto2.randomUUID();
-  const devVarsPath = path3.join(serverDir, ".dev.vars");
-  fs4.writeFileSync(devVarsPath, `ZOOID_JWT_SECRET=${jwtSecret}
+  const devVarsPath = path2.join(serverDir, ".dev.vars");
+  fs3.writeFileSync(devVarsPath, `ZOOID_JWT_SECRET=${jwtSecret}
 `);
   const adminToken = await createAdminToken(jwtSecret);
   const serverUrl = `http://localhost:${port}`;
   saveConfig({ admin_token: adminToken }, serverUrl);
-  const schemaPath = path3.join(serverDir, "src/db/schema.sql");
-  if (fs4.existsSync(schemaPath)) {
+  const schemaPath = path2.join(serverDir, "src/db/schema.sql");
+  if (fs3.existsSync(schemaPath)) {
     try {
       execSync(
         `npx wrangler d1 execute zooid-db --local --file=${schemaPath}`,
@@ -1062,11 +804,11 @@ async function runDev(port = 8787) {
   printSuccess("Local server configured");
   printInfo("Server", serverUrl);
   printInfo("Admin token", adminToken.slice(0, 20) + "...");
-  printInfo("Config saved to", "~/.zooid/config.json");
+  printInfo("Config saved to", "~/.zooid/state.json");
   console.log("");
   console.log("Starting wrangler dev...");
   console.log("");
-  const child = spawn(
+  const child = spawn2(
     "npx",
     ["wrangler", "dev", "--local", "--port", String(port)],
     {
@@ -1085,25 +827,25 @@ async function runDev(port = 8787) {
 }
 
 // src/commands/init.ts
-import fs5 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path3 from "path";
 import readline2 from "readline/promises";
-var CONFIG_FILENAME2 = "zooid.json";
-function getConfigPath2() {
-  return path4.join(process.cwd(), CONFIG_FILENAME2);
+var CONFIG_FILENAME = "zooid.json";
+function getConfigPath() {
+  return path3.join(process.cwd(), CONFIG_FILENAME);
 }
 function loadServerConfig() {
-  const configPath = getConfigPath2();
-  if (!fs5.existsSync(configPath)) return null;
-  const raw = fs5.readFileSync(configPath, "utf-8");
+  const configPath = getConfigPath();
+  if (!fs4.existsSync(configPath)) return null;
+  const raw = fs4.readFileSync(configPath, "utf-8");
   return JSON.parse(raw);
 }
 function saveServerConfig(config) {
-  const configPath = getConfigPath2();
-  fs5.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  const configPath = getConfigPath();
+  fs4.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 async function runInit() {
-  const configPath = getConfigPath2();
+  const configPath = getConfigPath();
   const existing = loadServerConfig();
   if (existing) {
     printInfo("Found existing", configPath);
@@ -1146,9 +888,9 @@ async function runInit() {
       tags,
       url
     };
-    fs5.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    fs4.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
     console.log("");
-    printSuccess(`Saved ${CONFIG_FILENAME2}`);
+    printSuccess(`Saved ${CONFIG_FILENAME}`);
     console.log("");
     printInfo("Name", config.name || "(not set)");
     printInfo("Description", config.description || "(not set)");
@@ -1169,63 +911,63 @@ async function runInit() {
 // src/commands/deploy.ts
 import { execSync as execSync2, spawnSync } from "child_process";
 import crypto3 from "crypto";
-import fs6 from "fs";
-import os2 from "os";
-import path5 from "path";
+import fs5 from "fs";
+import os from "os";
+import path4 from "path";
 import readline3 from "readline/promises";
 import { createRequire } from "module";
-import { ZooidClient as ZooidClient2 } from "@zooid/sdk";
+import { ZooidClient } from "@zooid/sdk";
 var require2 = createRequire(import.meta.url);
 function resolvePackageDir(packageName) {
   const pkgJson = require2.resolve(`${packageName}/package.json`);
-  return path5.dirname(pkgJson);
+  return path4.dirname(pkgJson);
 }
 function prepareStagingDir() {
   const serverDir = resolvePackageDir("@zooid/server");
-  const serverRequire = createRequire(path5.join(serverDir, "package.json"));
-  const webDir = path5.dirname(serverRequire.resolve("@zooid/web/package.json"));
-  const webDistDir = path5.join(webDir, "dist");
-  if (!fs6.existsSync(path5.join(serverDir, "wrangler.toml"))) {
+  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 (!fs6.existsSync(webDistDir)) {
+  if (!fs5.existsSync(webDistDir)) {
     throw new Error(`Web dashboard not built. Missing: ${webDistDir}`);
   }
-  const tmpDir = fs6.mkdtempSync(path5.join(os2.tmpdir(), "zooid-deploy-"));
-  copyDirSync(path5.join(serverDir, "src"), path5.join(tmpDir, "src"));
-  copyDirSync(webDistDir, path5.join(tmpDir, "web-dist"));
-  let toml = fs6.readFileSync(path5.join(serverDir, "wrangler.toml"), "utf-8");
+  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/"');
-  fs6.writeFileSync(path5.join(tmpDir, "wrangler.toml"), toml);
+  fs5.writeFileSync(path4.join(tmpDir, "wrangler.toml"), toml);
   const nodeModules = findServerNodeModules(serverDir);
   if (nodeModules) {
-    fs6.symlinkSync(nodeModules, path5.join(tmpDir, "node_modules"), "junction");
+    fs5.symlinkSync(nodeModules, path4.join(tmpDir, "node_modules"), "junction");
   }
   return tmpDir;
 }
 function findServerNodeModules(serverDir) {
-  const local = path5.join(serverDir, "node_modules");
-  if (fs6.existsSync(path5.join(local, "hono"))) return local;
-  const storeNodeModules = path5.resolve(serverDir, "..", "..");
-  if (fs6.existsSync(path5.join(storeNodeModules, "hono")))
+  const local = path4.join(serverDir, "node_modules");
+  if (fs5.existsSync(path4.join(local, "hono"))) return local;
+  const storeNodeModules = path4.resolve(serverDir, "..", "..");
+  if (fs5.existsSync(path4.join(storeNodeModules, "hono")))
     return storeNodeModules;
   let dir = serverDir;
-  while (dir !== path5.dirname(dir)) {
-    dir = path5.dirname(dir);
-    const nm = path5.join(dir, "node_modules");
-    if (fs6.existsSync(path5.join(nm, "hono"))) return nm;
+  while (dir !== path4.dirname(dir)) {
+    dir = path4.dirname(dir);
+    const nm = path4.join(dir, "node_modules");
+    if (fs5.existsSync(path4.join(nm, "hono"))) return nm;
   }
   return null;
 }
 function copyDirSync(src, dest) {
-  fs6.mkdirSync(dest, { recursive: true });
-  for (const entry of fs6.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path5.join(src, entry.name);
-    const destPath = path5.join(dest, entry.name);
+  fs5.mkdirSync(dest, { recursive: true });
+  for (const entry of fs5.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirSync(srcPath, destPath);
     } else {
-      fs6.copyFileSync(srcPath, destPath);
+      fs5.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -1279,9 +1021,9 @@ function parseDeployUrls(output) {
   };
 }
 function loadDotEnv() {
-  const envPath = path5.join(process.cwd(), ".env");
-  if (!fs6.existsSync(envPath)) return {};
-  const content = fs6.readFileSync(envPath, "utf-8");
+  const envPath = path4.join(process.cwd(), ".env");
+  if (!fs5.existsSync(envPath)) return {};
+  const content = fs5.readFileSync(envPath, "utf-8");
   const tokenMatch = content.match(/^CLOUDFLARE_API_TOKEN=(.+)$/m);
   const accountMatch = content.match(/^CLOUDFLARE_ACCOUNT_ID=(.+)$/m);
   return {
@@ -1386,8 +1128,8 @@ async function runDeploy() {
     }
     const databaseId = dbIdMatch[1];
     printSuccess(`D1 database created (${databaseId})`);
-    const wranglerTomlPath = path5.join(stagingDir, "wrangler.toml");
-    let tomlContent = fs6.readFileSync(wranglerTomlPath, "utf-8");
+    const wranglerTomlPath = path4.join(stagingDir, "wrangler.toml");
+    let tomlContent = fs5.readFileSync(wranglerTomlPath, "utf-8");
     tomlContent = tomlContent.replace(
       /name = "[^"]*"/,
       `name = "${workerName}"`
@@ -1404,10 +1146,10 @@ async function runDeploy() {
       /ZOOID_SERVER_ID = "[^"]*"/,
       `ZOOID_SERVER_ID = "${serverSlug}"`
     );
-    fs6.writeFileSync(wranglerTomlPath, tomlContent);
+    fs5.writeFileSync(wranglerTomlPath, tomlContent);
     printSuccess("Configured wrangler.toml");
-    const schemaPath = path5.join(stagingDir, "src/db/schema.sql");
-    if (fs6.existsSync(schemaPath)) {
+    const schemaPath = path4.join(stagingDir, "src/db/schema.sql");
+    if (fs5.existsSync(schemaPath)) {
       printStep("Running database schema migration...");
       wrangler(
         `d1 execute ${dbName} --remote --file=${schemaPath}`,
@@ -1462,8 +1204,8 @@ async function runDeploy() {
     console.log("");
     printInfo("Deploy type", "Redeploying existing server");
     console.log("");
-    const wranglerTomlPath = path5.join(stagingDir, "wrangler.toml");
-    let tomlContent = fs6.readFileSync(wranglerTomlPath, "utf-8");
+    const wranglerTomlPath = path4.join(stagingDir, "wrangler.toml");
+    let tomlContent = fs5.readFileSync(wranglerTomlPath, "utf-8");
     tomlContent = tomlContent.replace(
       /name = "[^"]*"/,
       `name = "${workerName}"`
@@ -1488,9 +1230,9 @@ async function runDeploy() {
       }
     } catch {
     }
-    fs6.writeFileSync(wranglerTomlPath, tomlContent);
-    const schemaPath = path5.join(stagingDir, "src/db/schema.sql");
-    if (fs6.existsSync(schemaPath)) {
+    fs5.writeFileSync(wranglerTomlPath, tomlContent);
+    const schemaPath = path4.join(stagingDir, "src/db/schema.sql");
+    if (fs5.existsSync(schemaPath)) {
       printStep("Running schema migration...");
       wrangler(
         `d1 execute ${dbName} --remote --file=${schemaPath}`,
@@ -1499,29 +1241,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"`,
@@ -1583,9 +1317,7 @@ async function runDeploy() {
       adminToken = existingConfig.admin_token;
     }
     if (!adminToken) {
-      printError(
-        "No admin token found in ~/.zooid/config.json for this server"
-      );
+      printError("No admin token found in ~/.zooid/state.json for this server");
       console.log(
         "If this is a first deploy, remove the D1 database and try again."
       );
@@ -1607,7 +1339,7 @@ async function runDeploy() {
   await new Promise((r) => setTimeout(r, 2e3));
   if (canonicalUrl && adminToken) {
     try {
-      const client = new ZooidClient2({
+      const client = new ZooidClient({
         server: canonicalUrl,
         token: adminToken
       });
@@ -1639,7 +1371,7 @@ async function runDeploy() {
     configToSave.channels = {};
   }
   saveConfig(configToSave, canonicalUrl || void 0);
-  printSuccess("Saved connection config to ~/.zooid/config.json");
+  printSuccess("Saved connection config to ~/.zooid/state.json");
   cleanup(stagingDir);
   console.log("");
   console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
@@ -1653,7 +1385,7 @@ async function runDeploy() {
   if (isFirstDeploy) {
     printInfo("Admin token", adminToken.slice(0, 20) + "...");
   }
-  printInfo("Config", "~/.zooid/config.json");
+  printInfo("Config", "~/.zooid/state.json");
   console.log("");
   if (isFirstDeploy) {
     console.log("  Next steps:");
@@ -1666,7 +1398,7 @@ async function runDeploy() {
 }
 function cleanup(dir) {
   try {
-    fs6.rmSync(dir, { recursive: true, force: true });
+    fs5.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -1694,13 +1426,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.0.0");
+program.name("zooid").description("\u{1FAB8} Pub/sub for AI agents").version("0.2.1");
 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) {
@@ -1804,8 +1536,8 @@ channelCmd.command("create <id>").description("Create a new channel").option("--
   try {
     let config;
     if (opts.schema) {
-      const fs7 = await import("fs");
-      const raw = fs7.readFileSync(opts.schema, "utf-8");
+      const fs6 = await import("fs");
+      const raw = fs6.readFileSync(opts.schema, "utf-8");
       const parsed = JSON.parse(raw);
       const types = {};
       for (const [eventType, schemaDef] of Object.entries(parsed)) {
@@ -1821,8 +1553,7 @@ 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);
   }
@@ -1840,8 +1571,8 @@ channelCmd.command("update <id>").description("Update a channel").option("--name
     if (opts.public) fields.is_public = true;
     if (opts.private) fields.is_public = false;
     if (opts.schema) {
-      const fs7 = await import("fs");
-      const raw = fs7.readFileSync(opts.schema, "utf-8");
+      const fs6 = await import("fs");
+      const raw = fs6.readFileSync(opts.schema, "utf-8");
       const parsed = JSON.parse(raw);
       const types = {};
       for (const [eventType, schemaDef] of Object.entries(parsed)) {
@@ -1930,9 +1661,40 @@ program.command("tail <channel>").description("Fetch latest events, or stream li
   "--mode <mode>",
   "Transport mode for follow: auto, ws, or poll",
   "auto"
-).option("--interval <ms>", "Poll interval in ms for follow mode", "5000").option("--token <token>", "Auth token (for remote/private channels)").action(async (channel, opts) => {
+).option("--interval <ms>", "Poll interval in ms for follow mode", "5000").option("--unseen", "Only show events since your last tail").option("--token <token>", "Auth token (for remote/private channels)").action(async (channel, opts) => {
   try {
-    const { client, channelId } = await resolveAndRecord(channel, opts);
+    let unseenCursor;
+    let unseenSince;
+    if (opts.unseen) {
+      const file = loadConfigFile();
+      const { parseChannelUrl } = await import("./client-4VMFEFDX.js");
+      const { resolveServer: resolveServer2 } = await import("./config-2KK5GX42.js");
+      const parsed = parseChannelUrl(channel);
+      const channelId2 = parsed?.channelId ?? channel;
+      const serverUrl = parsed?.server ?? resolveServer2();
+      const stats = serverUrl ? file.servers?.[serverUrl]?.channels?.[channelId2]?.stats : void 0;
+      if (!stats) {
+        throw new Error(
+          `No tail history for ${channelId2} \u2014 tail it at least once first`
+        );
+      }
+      if (stats.last_event_id) {
+        unseenCursor = stats.last_event_id;
+      } else if (stats.last_tailed_at) {
+        unseenSince = stats.last_tailed_at;
+      }
+    }
+    const { client, channelId, server } = await resolveAndRecord(
+      channel,
+      opts
+    );
+    if (opts.unseen) {
+      if (unseenCursor) {
+        opts.cursor = unseenCursor;
+      } else if (unseenSince) {
+        opts.since = unseenSince;
+      }
+    }
     if (opts.follow) {
       const mode = opts.mode;
       const transport = mode === "auto" ? "auto (WebSocket \u2192 poll fallback)" : mode;
@@ -1961,6 +1723,10 @@ program.command("tail <channel>").description("Fetch latest events, or stream li
         },
         client
       );
+      if (result.events.length > 0) {
+        const lastEvent = result.events[result.events.length - 1];
+        recordTailHistory(channelId, server, void 0, lastEvent.id);
+      }
       if (result.events.length === 0) {
         console.log("No events.");
       } else {
@@ -2048,22 +1814,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.0",
+  "version": "0.3.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/server": "^0.2.0",
-    "@zooid/types": "^0.2.0"
+    "@zooid/types": "^0.3.0",
+    "@zooid/sdk": "^0.3.0",
+    "@zooid/server": "^0.3.0"
   },
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "^0.8.34",