zooid 0.0.0 → 0.0.2

package/dist/index.js

@@ -0,0 +1,1680 @@
+#!/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');
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/lib/config.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) {
+  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, ...partial.channels };
+  }
+  file.servers[url] = merged;
+  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 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";
+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;
+  if (envVar !== void 0) {
+    return envVar !== "0" && envVar.toLowerCase() !== "false" && envVar.toLowerCase() !== "off";
+  }
+  const flag = readTelemetryFlag();
+  if (flag === false) return false;
+  return true;
+}
+function showNoticeIfNeeded() {
+  if (process.env.ZOOID_TELEMETRY === "0") return false;
+  const flag = readTelemetryFlag();
+  if (flag !== void 0) return false;
+  console.log("");
+  console.log("  Zooid collects anonymous usage metrics to improve the tool");
+  console.log("  and help rank channels in the public directory.");
+  console.log("");
+  console.log("  To opt out: npx zooid config set telemetry off");
+  console.log("  Or set ZOOID_TELEMETRY=0 in your environment.");
+  console.log("");
+  writeTelemetryFlag(true);
+  return true;
+}
+function writeEvent(event) {
+  const queuePath = getQueuePath();
+  const dir = getConfigDir();
+  try {
+    fs2.mkdirSync(dir, { recursive: true });
+    let queue = [];
+    try {
+      const raw = fs2.readFileSync(queuePath, "utf-8");
+      queue = JSON.parse(raw);
+    } catch {
+    }
+    queue.push(event);
+    if (queue.length > MAX_QUEUE_SIZE) {
+      queue = queue.slice(-MAX_QUEUE_SIZE);
+    }
+    fs2.writeFileSync(queuePath, JSON.stringify(queue, null, 2) + "\n");
+  } catch {
+  }
+}
+function flushInBackground() {
+  const queuePath = getQueuePath();
+  try {
+    const raw = fs2.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)], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env }
+    });
+    child.unref();
+  } catch {
+  }
+}
+function getInstallId() {
+  const configPath = path2.join(getConfigDir(), CONFIG_FILENAME);
+  try {
+    const raw = fs2.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.install_id) return parsed.install_id;
+  } catch {
+  }
+  const id = randomUUID();
+  persistToConfig("install_id", id);
+  return id;
+}
+function getQueuePath() {
+  return path2.join(getConfigDir(), QUEUE_FILENAME);
+}
+function readTelemetryFlag() {
+  const configPath = path2.join(getConfigDir(), CONFIG_FILENAME);
+  try {
+    const raw = fs2.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.telemetry === true) return true;
+    if (parsed.telemetry === false) return false;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeTelemetryFlag(enabled) {
+  persistToConfig("telemetry", enabled);
+}
+function persistToConfig(key, value) {
+  const dir = getConfigDir();
+  const configPath = path2.join(dir, CONFIG_FILENAME);
+  try {
+    fs2.mkdirSync(dir, { recursive: true });
+    let config = {};
+    try {
+      const raw = fs2.readFileSync(configPath, "utf-8");
+      config = JSON.parse(raw);
+    } catch {
+    }
+    config[key] = value;
+    fs2.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  } catch {
+  }
+}
+function flushScript(queuePath) {
+  return `
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+
+try {
+  const raw = fs.readFileSync(${JSON.stringify(queuePath)}, 'utf-8');
+  const events = JSON.parse(raw);
+  if (!Array.isArray(events) || events.length === 0) process.exit(0);
+
+  const body = JSON.stringify({ events });
+  const url = new URL(${JSON.stringify(TELEMETRY_ENDPOINT)});
+  const transport = url.protocol === 'https:' ? https : http;
+
+  const req = transport.request(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body),
+    },
+    timeout: 5000,
+  }, (res) => {
+    if (res.statusCode >= 200 && res.statusCode < 300) {
+      fs.writeFileSync(${JSON.stringify(queuePath)}, '[]\\n');
+    }
+    process.exit(0);
+  });
+
+  req.on('error', () => process.exit(0));
+  req.on('timeout', () => { req.destroy(); process.exit(0); });
+  req.write(body);
+  req.end();
+} catch (e) {
+  process.exit(0);
+}
+`.trim();
+}
+
+// src/commands/config.ts
+var VALID_KEYS = ["server", "admin-token", "telemetry"];
+function runConfigSet(key, value) {
+  if (key === "server") {
+    switchServer(value);
+  } else if (key === "admin-token") {
+    saveConfig({ admin_token: value });
+  } else if (key === "telemetry") {
+    const enabled = value === "on" || value === "true" || value === "1";
+    writeTelemetryFlag(enabled);
+  } else {
+    throw new Error(
+      `Unknown config key: "${key}". Valid keys: ${VALID_KEYS.join(", ")}`
+    );
+  }
+}
+function runConfigGet(key) {
+  const config = loadConfig();
+  if (key === "server") return config.server;
+  if (key === "admin-token") return config.admin_token;
+  if (key === "telemetry") return isEnabled() ? "on" : "off";
+  throw new Error(
+    `Unknown config key: "${key}". Valid keys: ${VALID_KEYS.join(", ")}`
+  );
+}
+
+// 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 createPublishClient(channelId) {
+  const config = loadConfig();
+  const server = config.server;
+  if (!server) {
+    throw new Error(
+      "No server configured. Run: npx zooid config set server <url>"
+    );
+  }
+  const channelToken = config.channels?.[channelId]?.publish_token;
+  return new ZooidClient({ server, token: channelToken ?? config.admin_token });
+}
+function createSubscribeClient(channelId) {
+  const config = loadConfig();
+  const server = config.server;
+  if (!server) {
+    throw new Error(
+      "No server configured. Run: npx zooid config set server <url>"
+    );
+  }
+  const channelToken = config.channels?.[channelId]?.subscribe_token;
+  return new ZooidClient({ server, token: channelToken ?? config.admin_token });
+}
+
+// src/commands/channel.ts
+async function runChannelCreate(id, options, client) {
+  const c = client ?? createClient();
+  const result = await c.createChannel({
+    id,
+    name: options.name ?? id,
+    description: options.description,
+    is_public: options.public ?? true,
+    strict: options.strict,
+    schema: options.schema
+  });
+  if (!client) {
+    const config = loadConfig();
+    const channels = config.channels ?? {};
+    channels[id] = {
+      publish_token: result.publish_token,
+      subscribe_token: result.subscribe_token
+    };
+    saveConfig({ channels });
+  }
+  return result;
+}
+async function runChannelList(client) {
+  const c = client ?? createClient();
+  return c.listChannels();
+}
+async function runChannelAddPublisher(channelId, name, client) {
+  const c = client ?? createClient();
+  return c.addPublisher(channelId, name);
+}
+
+// src/commands/publish.ts
+import fs3 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 parsed = JSON.parse(raw);
+    type = parsed.type;
+    data = parsed.data ?? parsed;
+  } else if (options.data) {
+    data = JSON.parse(options.data);
+    type = options.type;
+  } else {
+    throw new Error("Either --data or --file is required");
+  }
+  const publishOpts = { data };
+  if (type) publishOpts.type = type;
+  return c.publish(channelId, publishOpts);
+}
+
+// src/commands/subscribe.ts
+async function runSubscribePoll(channelId, options = {}, client) {
+  const c = client ?? createSubscribeClient(channelId);
+  const callback = options.callback ?? ((event) => {
+    console.log(JSON.stringify(event));
+  });
+  return c.subscribe(channelId, callback, {
+    interval: options.interval ?? 5e3,
+    mode: options.mode,
+    type: options.type
+  });
+}
+async function runSubscribeWebhook(channelId, url, client) {
+  const c = client ?? createSubscribeClient(channelId);
+  return c.registerWebhook(channelId, url);
+}
+
+// src/commands/tail.ts
+async function runTail(channelId, options = {}, client) {
+  const c = client ?? createSubscribeClient(channelId);
+  if (options.follow) {
+    return runTailFollow(c, channelId, options);
+  }
+  const pollOpts = {};
+  if (options.limit !== void 0) pollOpts.limit = options.limit;
+  if (options.type) pollOpts.type = options.type;
+  if (options.since) pollOpts.since = options.since;
+  if (options.cursor) pollOpts.cursor = options.cursor;
+  return c.tail(channelId, pollOpts);
+}
+async function runTailFollow(client, channelId, options) {
+  const tailOpts = {
+    follow: true,
+    mode: options.mode,
+    interval: options.interval,
+    type: options.type
+  };
+  const stream = client.tail(channelId, tailOpts);
+  for await (const event of stream) {
+    console.log(JSON.stringify(event));
+  }
+  return void 0;
+}
+
+// src/commands/status.ts
+async function runStatus(client) {
+  const c = client ?? createClient();
+  const [discovery, identity] = await Promise.all([
+    c.getMetadata(),
+    c.getServerMeta()
+  ]);
+  return { discovery, identity };
+}
+
+// src/commands/share.ts
+import readline from "readline/promises";
+
+// src/lib/output.ts
+function printSuccess(message) {
+  console.log(`\u2713 ${message}`);
+}
+function printError(message) {
+  console.error(`\u2717 ${message}`);
+}
+function printInfo(label, value) {
+  console.log(`  ${label}: ${value}`);
+}
+
+// src/lib/directory.ts
+var DIRECTORY_BASE_URL = "https://directory.zooid.dev";
+var TOKEN_PREFIX = "zd_";
+var POLL_INTERVAL_MS = 3e3;
+var POLL_TIMEOUT_MS = 2 * 60 * 1e3;
+function getDirectoryToken() {
+  const token = loadDirectoryToken();
+  if (token && token.startsWith(TOKEN_PREFIX)) {
+    return token;
+  }
+  return void 0;
+}
+async function ensureDirectoryToken() {
+  const existing = getDirectoryToken();
+  if (existing) return existing;
+  return deviceAuth();
+}
+async function deviceAuth() {
+  const res = await fetch(`${DIRECTORY_BASE_URL}/api/auth/device`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`Directory auth failed: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  const { device_code, verification_url } = data;
+  console.log("");
+  printInfo("Authorize", verification_url);
+  console.log("  Opening browser to complete GitHub sign-in...\n");
+  try {
+    const { exec } = await import("child_process");
+    const platform = process.platform;
+    const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+    exec(`${cmd} "${verification_url}"`);
+  } catch {
+    console.log(
+      "  Could not open browser automatically. Please visit the URL above.\n"
+    );
+  }
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await sleep(POLL_INTERVAL_MS);
+    const statusRes = await fetch(
+      `${DIRECTORY_BASE_URL}/api/auth/status?code=${encodeURIComponent(device_code)}`
+    );
+    if (!statusRes.ok) continue;
+    const status = await statusRes.json();
+    if (status.status === "complete" && status.token) {
+      saveDirectoryToken(status.token);
+      console.log("  Authenticated with Zooid Directory.\n");
+      return status.token;
+    }
+    if (status.status === "expired") {
+      throw new Error("Device authorization expired. Please try again.");
+    }
+  }
+  throw new Error(
+    "Authorization timed out. You need your human to authorize you. Run `npx zooid share` again to retry."
+  );
+}
+async function directoryFetch(path6, 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 });
+  };
+  let res = await doFetch(token);
+  if (res.status === 401) {
+    console.log("  Directory token expired. Re-authenticating...\n");
+    token = await deviceAuth();
+    res = await doFetch(token);
+  }
+  return res;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/share.ts
+async function runShare(channelIds, options = {}) {
+  const client = createClient();
+  const config = loadConfig();
+  const serverUrl = config.server;
+  if (!serverUrl) {
+    throw new Error(
+      "No server configured. Run: npx zooid config set server <url>"
+    );
+  }
+  const allChannels = await client.listChannels();
+  const publicChannels = allChannels.filter((ch) => ch.is_public);
+  if (publicChannels.length === 0) {
+    throw new Error("No public channels found on this server.");
+  }
+  let selected;
+  if (channelIds.length > 0) {
+    const byId = new Map(allChannels.map((ch) => [ch.id, ch]));
+    const missing = [];
+    selected = [];
+    for (const id of channelIds) {
+      const ch = byId.get(id);
+      if (!ch) {
+        missing.push(id);
+      } else {
+        selected.push(ch);
+      }
+    }
+    if (missing.length > 0) {
+      throw new Error(`Channels not found: ${missing.join(", ")}`);
+    }
+    const privateChannels = selected.filter((ch) => !ch.is_public);
+    if (privateChannels.length > 0) {
+      throw new Error(
+        `Cannot share private channels: ${privateChannels.map((ch) => ch.id).join(", ")}. Only public channels can be listed in the directory.`
+      );
+    }
+  } else if (options.yes) {
+    selected = publicChannels;
+  } else {
+    selected = await pickChannels(publicChannels);
+    if (selected.length === 0) {
+      throw new Error("No channels selected.");
+    }
+  }
+  const channelDetails = await promptChannelDetails(selected, options.yes);
+  const ids = selected.map((ch) => ch.id);
+  const { claim, signature } = await client.getClaim(ids);
+  const channels = selected.map((ch) => {
+    const details = channelDetails.get(ch.id);
+    const entry = {
+      channel_id: ch.id,
+      name: ch.name
+    };
+    if (details.description) entry.description = details.description;
+    if (details.tags.length > 0) entry.tags = details.tags;
+    return entry;
+  });
+  const res = await directoryFetch("/api/servers", {
+    method: "POST",
+    body: JSON.stringify({ server_url: serverUrl, claim, signature, channels })
+  });
+  if (!res.ok) {
+    throw new Error(await formatDirectoryError(res));
+  }
+  const result = await res.json();
+  console.log("");
+  for (const ch of selected) {
+    const dirChannel = result.channels?.find((c) => c.channel_id === ch.id);
+    const url = dirChannel?.directory_url ?? `${DIRECTORY_BASE_URL}/servers/${encodeURIComponent(serverUrl)}/${ch.id}`;
+    console.log(`  ${ch.id} \u2192 ${url}`);
+  }
+  console.log("");
+}
+async function pickChannels(channels) {
+  const { default: checkbox } = await import("@inquirer/checkbox");
+  const selected = await checkbox({
+    message: "Select channels to share",
+    choices: channels.map((ch) => ({
+      name: ch.description ? `${ch.id} \u2014 ${ch.description}` : ch.id,
+      value: ch.id,
+      checked: true
+    })),
+    theme: {
+      icon: { cursor: "> " },
+      style: { highlight: (text) => text }
+    }
+  });
+  const selectedSet = new Set(selected);
+  return channels.filter((ch) => selectedSet.has(ch.id));
+}
+async function promptChannelDetails(channels, skipPrompt) {
+  const result = /* @__PURE__ */ new Map();
+  if (skipPrompt) {
+    for (const ch of channels) {
+      result.set(ch.id, {
+        description: ch.description ?? "",
+        tags: ch.tags
+      });
+    }
+    return result;
+  }
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log("");
+    console.log("  Set description and tags for each channel.");
+    console.log("  Press Enter to accept defaults shown in [brackets].\n");
+    for (const ch of channels) {
+      console.log(`  ${ch.id}:`);
+      const desc = await ask(rl, "Description", ch.description ?? "");
+      const tagsRaw = await ask(
+        rl,
+        "Tags (comma-separated)",
+        ch.tags.join(", ")
+      );
+      const tags = tagsRaw.split(",").map((t) => t.trim()).filter(Boolean);
+      result.set(ch.id, { description: desc, tags });
+      console.log("");
+    }
+  } finally {
+    rl.close();
+  }
+  return result;
+}
+async function ask(rl, label, defaultValue) {
+  const hint = defaultValue ? ` [${defaultValue}]` : "";
+  const answer = await rl.question(`  ${label}${hint}: `);
+  return answer.trim() || defaultValue;
+}
+async function formatDirectoryError(res) {
+  let msg = `Directory returned ${res.status}`;
+  try {
+    const body = await res.json();
+    const parts = [];
+    if (body.error) parts.push(String(body.error));
+    if (body.message) parts.push(String(body.message));
+    if (parts.length > 0) msg = parts.join(": ");
+  } catch {
+  }
+  return msg;
+}
+
+// src/commands/unshare.ts
+async function runUnshare(channelId) {
+  const client = createClient();
+  const config = loadConfig();
+  const serverUrl = config.server;
+  if (!serverUrl) {
+    throw new Error(
+      "No server configured. Run: npx zooid config set server <url>"
+    );
+  }
+  const { claim, signature } = await client.getClaim([channelId], "delete");
+  const res = await directoryFetch("/api/servers/channels", {
+    method: "DELETE",
+    body: JSON.stringify({
+      server_url: serverUrl,
+      channel_id: channelId,
+      claim,
+      signature
+    })
+  });
+  if (!res.ok) {
+    throw new Error(await formatDirectoryError2(res));
+  }
+}
+async function formatDirectoryError2(res) {
+  let msg = `Directory returned ${res.status}`;
+  try {
+    const body = await res.json();
+    const parts = [];
+    if (body.error) parts.push(String(body.error));
+    if (body.message) parts.push(String(body.message));
+    if (parts.length > 0) msg = parts.join(": ");
+  } catch {
+  }
+  return msg;
+}
+
+// src/commands/discover.ts
+async function runDiscover(options) {
+  const params = new URLSearchParams();
+  if (options.query) params.set("q", options.query);
+  if (options.tag) params.set("tag", options.tag);
+  if (options.limit) params.set("limit", String(options.limit));
+  const qs = params.toString();
+  const url = `${DIRECTORY_BASE_URL}/api/discover${qs ? `?${qs}` : ""}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Directory returned ${res.status}`);
+  }
+  const data = await res.json();
+  if (data.channels.length === 0) {
+    console.log("No channels found.");
+    return;
+  }
+  console.log("");
+  for (const ch of data.channels) {
+    const host = new URL(ch.server_url).host;
+    const tags = ch.tags.length > 0 ? ` [${ch.tags.join(", ")}]` : "";
+    const desc = ch.description ? ` \u2014 ${ch.description}` : "";
+    console.log(`  ${host}/${ch.channel_id}${desc}${tags}`);
+  }
+  console.log(`
+  ${data.total} channel${data.total === 1 ? "" : "s"} found.`);
+  console.log("");
+}
+
+// src/commands/server.ts
+async function runServerGet(client) {
+  const c = client ?? createClient();
+  return c.getServerMeta();
+}
+async function runServerSet(fields, client) {
+  const c = client ?? createClient();
+  return c.updateServerMeta(fields);
+}
+
+// src/commands/dev.ts
+import { execSync, spawn } from "child_process";
+import crypto from "crypto";
+import fs4 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+function findServerDir() {
+  const cliDir = path3.dirname(fileURLToPath(import.meta.url));
+  return path3.resolve(cliDir, "../../server");
+}
+function base64url(buf) {
+  return buf.toString("base64url");
+}
+async function createAdminToken(secret) {
+  const header = base64url(
+    Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" }))
+  );
+  const payload = base64url(
+    Buffer.from(
+      JSON.stringify({
+        scope: "admin",
+        iat: Math.floor(Date.now() / 1e3)
+      })
+    )
+  );
+  const data = `${header}.${payload}`;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    new TextEncoder().encode(data)
+  );
+  const signature = base64url(Buffer.from(sig));
+  return `${data}.${signature}`;
+}
+async function runDev(port = 8787) {
+  const serverDir = findServerDir();
+  if (!fs4.existsSync(path3.join(serverDir, "wrangler.toml"))) {
+    throw new Error(
+      `Server directory not found at ${serverDir}. Make sure you're running from the zooid monorepo.`
+    );
+  }
+  const jwtSecret = crypto.randomUUID();
+  const devVarsPath = path3.join(serverDir, ".dev.vars");
+  fs4.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)) {
+    try {
+      execSync(
+        `npx wrangler d1 execute zooid-db --local --file=${schemaPath}`,
+        {
+          cwd: serverDir,
+          stdio: "pipe"
+        }
+      );
+      printSuccess("Database schema initialized");
+    } catch {
+      printSuccess("Database ready (schema already exists)");
+    }
+  }
+  printSuccess("Local server configured");
+  printInfo("Server", serverUrl);
+  printInfo("Admin token", adminToken.slice(0, 20) + "...");
+  printInfo("Config saved to", "~/.zooid/config.json");
+  console.log("");
+  console.log("Starting wrangler dev...");
+  console.log("");
+  const child = spawn(
+    "npx",
+    ["wrangler", "dev", "--local", "--port", String(port)],
+    {
+      cwd: serverDir,
+      stdio: "inherit",
+      shell: true
+    }
+  );
+  child.on("error", (err) => {
+    console.error(`Failed to start local server: ${err.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+
+// src/commands/init.ts
+import fs5 from "fs";
+import path4 from "path";
+import readline2 from "readline/promises";
+var CONFIG_FILENAME2 = "zooid.json";
+function getConfigPath2() {
+  return path4.join(process.cwd(), CONFIG_FILENAME2);
+}
+function loadServerConfig() {
+  const configPath = getConfigPath2();
+  if (!fs5.existsSync(configPath)) return null;
+  const raw = fs5.readFileSync(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveServerConfig(config) {
+  const configPath = getConfigPath2();
+  fs5.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+async function runInit() {
+  const configPath = getConfigPath2();
+  const existing = loadServerConfig();
+  if (existing) {
+    printInfo("Found existing", configPath);
+    console.log("");
+  }
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log("");
+    console.log("  Configure your Zooid server");
+    console.log("  Press Enter to accept defaults shown in [brackets].\n");
+    const name = await ask2(rl, "Server name", existing?.name ?? "");
+    const description = await ask2(
+      rl,
+      "Description",
+      existing?.description ?? ""
+    );
+    const owner = await ask2(rl, "Owner", existing?.owner ?? "");
+    const company = await ask2(rl, "Company", existing?.company ?? "");
+    const email = await ask2(rl, "Email", existing?.email ?? "");
+    const tagsRaw = await ask2(
+      rl,
+      "Tags (comma-separated)",
+      existing?.tags?.join(", ") ?? ""
+    );
+    const url = await ask2(rl, "URL", existing?.url ?? "");
+    const tags = tagsRaw.split(",").map((t) => t.trim()).filter(Boolean);
+    const config = {
+      name,
+      description,
+      owner,
+      company,
+      email,
+      tags,
+      url
+    };
+    fs5.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    console.log("");
+    printSuccess(`Saved ${CONFIG_FILENAME2}`);
+    console.log("");
+    printInfo("Name", config.name || "(not set)");
+    printInfo("Description", config.description || "(not set)");
+    printInfo("Owner", config.owner || "(not set)");
+    printInfo("Company", config.company || "(not set)");
+    printInfo("Email", config.email || "(not set)");
+    printInfo(
+      "Tags",
+      config.tags.length > 0 ? config.tags.join(", ") : "(none)"
+    );
+    printInfo("URL", config.url || "(not set)");
+    console.log("");
+  } finally {
+    rl.close();
+  }
+}
+async function ask2(rl, label, defaultValue) {
+  const hint = defaultValue ? ` [${defaultValue}]` : "";
+  const answer = await rl.question(`  ${label}${hint}: `);
+  return answer.trim() || defaultValue;
+}
+
+// src/commands/deploy.ts
+import { execSync as execSync2 } from "child_process";
+import crypto2 from "crypto";
+import fs6 from "fs";
+import os2 from "os";
+import path5 from "path";
+import readline3 from "readline/promises";
+import { createRequire } from "module";
+import { ZooidClient as ZooidClient2 } from "@zooid/sdk";
+var require2 = createRequire(import.meta.url);
+function resolvePackageDir(packageName) {
+  const pkgJson = require2.resolve(`${packageName}/package.json`);
+  return path5.dirname(pkgJson);
+}
+function prepareStagingDir() {
+  const serverDir = resolvePackageDir("@zooid/server");
+  const webDir = resolvePackageDir("@zooid/web");
+  const webDistDir = path5.join(webDir, "dist");
+  if (!fs6.existsSync(path5.join(serverDir, "wrangler.toml"))) {
+    throw new Error(`Server package missing wrangler.toml at ${serverDir}`);
+  }
+  if (!fs6.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");
+  toml = toml.replace(/directory\s*=\s*"[^"]*"/, 'directory = "./web-dist/"');
+  fs6.writeFileSync(path5.join(tmpDir, "wrangler.toml"), toml);
+  const nodeModules = findServerNodeModules(serverDir);
+  if (nodeModules) {
+    fs6.symlinkSync(nodeModules, path5.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")))
+    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;
+  }
+  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);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs6.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function base64url2(buf) {
+  return buf.toString("base64url");
+}
+async function createAdminToken2(secret) {
+  const header = base64url2(
+    Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" }))
+  );
+  const payload = base64url2(
+    Buffer.from(
+      JSON.stringify({
+        scope: "admin",
+        iat: Math.floor(Date.now() / 1e3)
+      })
+    )
+  );
+  const data = `${header}.${payload}`;
+  const key = await crypto2.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto2.subtle.sign(
+    "HMAC",
+    key,
+    new TextEncoder().encode(data)
+  );
+  const signature = base64url2(Buffer.from(sig));
+  return `${data}.${signature}`;
+}
+function wrangler(cmd, cwd, creds, opts) {
+  const env = {
+    ...process.env,
+    CLOUDFLARE_API_TOKEN: creds.apiToken
+  };
+  if (creds.accountId) {
+    env.CLOUDFLARE_ACCOUNT_ID = creds.accountId;
+  }
+  return execSync2(`npx wrangler ${cmd}`, {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf-8",
+    env,
+    input: opts?.input
+  });
+}
+function parseDeployUrls(output) {
+  const workersDev = output.match(/https:\/\/[^\s]+\.workers\.dev/);
+  const custom = output.match(
+    /^\s+(\S+\.(?!workers\.dev)\S+)\s+\(custom domain\)/m
+  );
+  return {
+    workerUrl: workersDev ? workersDev[0] : null,
+    customDomain: custom ? `https://${custom[1]}` : null
+  };
+}
+function loadDotEnv() {
+  const envPath = path5.join(process.cwd(), ".env");
+  if (!fs6.existsSync(envPath)) return {};
+  const content = fs6.readFileSync(envPath, "utf-8");
+  const tokenMatch = content.match(/^CLOUDFLARE_API_TOKEN=(.+)$/m);
+  const accountMatch = content.match(/^CLOUDFLARE_ACCOUNT_ID=(.+)$/m);
+  return {
+    apiToken: tokenMatch ? tokenMatch[1].trim() : void 0,
+    accountId: accountMatch ? accountMatch[1].trim() : void 0
+  };
+}
+async function getCfCredentials() {
+  const envToken = process.env.CLOUDFLARE_API_TOKEN;
+  const envAccount = process.env.CLOUDFLARE_ACCOUNT_ID;
+  if (envToken) {
+    return { apiToken: envToken, accountId: envAccount };
+  }
+  const dotEnv = loadDotEnv();
+  if (dotEnv.apiToken) {
+    printInfo("Using credentials from", ".env");
+    return { apiToken: dotEnv.apiToken, accountId: dotEnv.accountId };
+  }
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log("");
+    console.log("  Cloudflare API token required for deployment.");
+    console.log("  Go to: https://dash.cloudflare.com/profile/api-tokens");
+    console.log(
+      '  Use the "Edit Cloudflare Workers" template, then add D1 Edit permission.'
+    );
+    console.log("  Tip: save credentials in .env to skip this prompt.");
+    console.log("");
+    const token = await rl.question("  API token: ");
+    const accountId = await rl.question(
+      "  Account ID (from the dashboard URL or Workers overview): "
+    );
+    return {
+      apiToken: token.trim(),
+      accountId: accountId.trim() || void 0
+    };
+  } finally {
+    rl.close();
+  }
+}
+async function runDeploy() {
+  let config = loadServerConfig();
+  if (!config) {
+    printInfo("No zooid.json found", "starting setup...");
+    console.log("");
+    await runInit();
+    config = loadServerConfig();
+  }
+  if (!config) {
+    printError("Failed to load zooid.json after init");
+    process.exit(1);
+  }
+  let stagingDir;
+  try {
+    stagingDir = prepareStagingDir();
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+  const serverSlug = config.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
+  const dbName = `zooid-db-${serverSlug}`;
+  const workerName = `zooid-${serverSlug}`;
+  try {
+    execSync2("npx wrangler --version", { cwd: stagingDir, stdio: "pipe" });
+  } catch {
+    printError("wrangler not found. Install with: npm install -g wrangler");
+    process.exit(1);
+  }
+  const creds = await getCfCredentials();
+  try {
+    wrangler("whoami", stagingDir, creds);
+    printSuccess("Cloudflare authentication verified");
+  } catch {
+    printError("Invalid Cloudflare API token");
+    cleanup(stagingDir);
+    process.exit(1);
+  }
+  let isFirstDeploy = false;
+  try {
+    const output = wrangler("d1 list --json", stagingDir, creds);
+    const databases = JSON.parse(output);
+    isFirstDeploy = !databases.some((db) => db.name === dbName);
+  } catch {
+    isFirstDeploy = true;
+  }
+  let adminToken;
+  if (isFirstDeploy) {
+    console.log("");
+    printInfo("Deploy type", "First deploy \u2014 setting up database and secrets");
+    console.log("");
+    console.log(`Creating D1 database (${dbName})...`);
+    const d1Output = wrangler(`d1 create ${dbName}`, stagingDir, creds);
+    const dbIdMatch = d1Output.match(/database_id\s*=\s*"([^"]+)"/);
+    if (!dbIdMatch) {
+      printError("Failed to parse database ID from wrangler output");
+      console.log(d1Output);
+      cleanup(stagingDir);
+      process.exit(1);
+    }
+    const databaseId = dbIdMatch[1];
+    printSuccess(`D1 database created (${databaseId})`);
+    const wranglerTomlPath = path5.join(stagingDir, "wrangler.toml");
+    let tomlContent = fs6.readFileSync(wranglerTomlPath, "utf-8");
+    tomlContent = tomlContent.replace(
+      /name = "[^"]*"/,
+      `name = "${workerName}"`
+    );
+    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}"`
+    );
+    fs6.writeFileSync(wranglerTomlPath, tomlContent);
+    printSuccess("Configured wrangler.toml");
+    const schemaPath = path5.join(stagingDir, "src/db/schema.sql");
+    if (fs6.existsSync(schemaPath)) {
+      console.log("Running database schema migration...");
+      wrangler(
+        `d1 execute ${dbName} --remote --file=${schemaPath}`,
+        stagingDir,
+        creds
+      );
+      printSuccess("Database schema initialized");
+    }
+    console.log("Generating secrets...");
+    const jwtSecret = crypto2.randomBytes(32).toString("base64");
+    const keyPair = await crypto2.subtle.generateKey("Ed25519", true, [
+      "sign",
+      "verify"
+    ]);
+    const privateKeyRaw = await crypto2.subtle.exportKey(
+      "pkcs8",
+      keyPair.privateKey
+    );
+    const publicKeyRaw = await crypto2.subtle.exportKey(
+      "raw",
+      keyPair.publicKey
+    );
+    const privateKeyB64 = Buffer.from(privateKeyRaw).toString("base64");
+    const publicKeyB64 = Buffer.from(publicKeyRaw).toString("base64");
+    wrangler("secret put ZOOID_JWT_SECRET", stagingDir, creds, {
+      input: jwtSecret
+    });
+    printSuccess("Set ZOOID_JWT_SECRET");
+    wrangler("secret put ZOOID_SIGNING_KEY", stagingDir, creds, {
+      input: privateKeyB64
+    });
+    printSuccess("Set ZOOID_SIGNING_KEY (Ed25519 private)");
+    wrangler("secret put ZOOID_PUBLIC_KEY", stagingDir, creds, {
+      input: publicKeyB64
+    });
+    printSuccess("Set ZOOID_PUBLIC_KEY (Ed25519 public)");
+    adminToken = await createAdminToken2(jwtSecret);
+    printSuccess("Admin token generated");
+  } else {
+    console.log("");
+    printInfo("Deploy type", "Redeploying existing server");
+    console.log("");
+    const wranglerTomlPath = path5.join(stagingDir, "wrangler.toml");
+    let tomlContent = fs6.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}"`
+        );
+      }
+    } catch {
+    }
+    fs6.writeFileSync(wranglerTomlPath, tomlContent);
+    const existingConfig = loadConfig();
+    adminToken = existingConfig.admin_token;
+    if (!adminToken) {
+      printError(
+        "No admin token found in ~/.zooid/config.json for this server"
+      );
+      console.log(
+        "If this is a first deploy, remove the D1 database and try again."
+      );
+      cleanup(stagingDir);
+      process.exit(1);
+    }
+  }
+  console.log("Deploying worker...");
+  const deployOutput = wrangler("deploy", stagingDir, creds);
+  const { workerUrl, customDomain } = parseDeployUrls(deployOutput);
+  printSuccess("Worker deployed");
+  if (workerUrl) {
+    printInfo("Worker URL", workerUrl);
+  }
+  if (customDomain) {
+    printInfo("Custom domain", customDomain);
+  }
+  const canonicalUrl = config.url || customDomain || workerUrl;
+  await new Promise((r) => setTimeout(r, 2e3));
+  if (canonicalUrl && adminToken) {
+    try {
+      const client = new ZooidClient2({
+        server: canonicalUrl,
+        token: adminToken
+      });
+      await client.updateServerMeta({
+        name: config.name || void 0,
+        description: config.description || void 0,
+        tags: config.tags.length > 0 ? config.tags : void 0,
+        owner: config.owner || void 0,
+        company: config.company || void 0,
+        email: config.email || void 0
+      });
+      printSuccess("Server identity updated");
+    } catch (err) {
+      printError(
+        `Failed to push server identity: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+  if (!config.url && (customDomain || workerUrl)) {
+    config.url = customDomain || workerUrl;
+    saveServerConfig(config);
+    printSuccess("Saved URL to zooid.json");
+  }
+  const configToSave = {
+    worker_url: workerUrl || void 0,
+    admin_token: adminToken
+  };
+  if (isFirstDeploy) {
+    configToSave.channels = {};
+  }
+  saveConfig(configToSave, canonicalUrl || void 0);
+  printSuccess("Saved connection config to ~/.zooid/config.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");
+  console.log("  \u{1FAB8} Zooid server deployed!");
+  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");
+  printInfo("Server", canonicalUrl || "(unknown)");
+  if (workerUrl && workerUrl !== canonicalUrl) {
+    printInfo("Worker URL", workerUrl);
+  }
+  printInfo("Name", config.name || "(not set)");
+  if (isFirstDeploy) {
+    printInfo("Admin token", adminToken.slice(0, 20) + "...");
+  }
+  printInfo("Config", "~/.zooid/config.json");
+  console.log("");
+  if (isFirstDeploy) {
+    console.log("  Next steps:");
+    console.log("    npx zooid channel create my-channel");
+    console.log(
+      `    npx zooid publish my-channel --data='{"hello": "world"}'`
+    );
+    console.log("");
+  }
+}
+function cleanup(dir) {
+  try {
+    fs6.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("zooid").description("\u{1FAB8} Pub/sub for AI agents").version("0.0.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);
+  telemetryCtx.usedToken = hasChannelToken || !!config.admin_token;
+}
+function getCommandPath(cmd) {
+  const parts = [];
+  let current = cmd;
+  while (current && current !== program) {
+    parts.unshift(current.name());
+    current = current.parent;
+  }
+  return parts.join(" ");
+}
+program.hook("preAction", () => {
+  telemetryCtx.startTime = Date.now();
+  if (isEnabled()) {
+    showNoticeIfNeeded();
+  }
+});
+program.hook("postAction", (thisCommand) => {
+  if (!isEnabled()) return;
+  try {
+    const event = {
+      install_id: getInstallId(),
+      command: getCommandPath(thisCommand),
+      exit_code: 0,
+      duration_ms: Date.now() - telemetryCtx.startTime,
+      cli_version: program.version() ?? "0.0.0",
+      os: process.platform,
+      arch: process.arch,
+      node_version: process.version,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (telemetryCtx.channelId && !telemetryCtx.usedToken) {
+      event.channel_id = telemetryCtx.channelId;
+      const config = loadConfig();
+      if (config.server) event.server_url = config.server;
+    }
+    writeEvent(event);
+    flushInBackground();
+  } catch {
+  }
+  telemetryCtx.channelId = void 0;
+  telemetryCtx.usedToken = void 0;
+});
+program.command("dev").description("Start local development server").option("--port <port>", "Server port", "8787").action(async (opts) => {
+  try {
+    await runDev(parseInt(opts.port, 10));
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("init").description("Create zooid-server.json with server identity").action(async () => {
+  try {
+    await runInit();
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("deploy").description("Deploy Zooid server to Cloudflare Workers").action(async () => {
+  try {
+    await runDeploy();
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+var configCmd = program.command("config").description("Manage Zooid configuration");
+configCmd.command("set <key> <value>").description("Set a config value (server, admin-token, telemetry)").action((key, value) => {
+  try {
+    runConfigSet(key, value);
+    printSuccess(`Set ${key}`);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+configCmd.command("get <key>").description("Get a config value").action((key) => {
+  try {
+    const value = runConfigGet(key);
+    if (value) {
+      console.log(value);
+    } else {
+      console.log("(not set)");
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+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("--schema <file>", "Path to JSON schema file").action(async (id, opts) => {
+  try {
+    let schema;
+    if (opts.schema) {
+      const fs7 = await import("fs");
+      const raw = fs7.readFileSync(opts.schema, "utf-8");
+      schema = JSON.parse(raw);
+    }
+    const result = await runChannelCreate(id, {
+      name: opts.name,
+      description: opts.description,
+      public: opts.private ? false : true,
+      strict: opts.strict,
+      schema
+    });
+    printSuccess(`Created channel: ${id}`);
+    printInfo("Publish token", result.publish_token);
+    printInfo("Subscribe token", result.subscribe_token);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+channelCmd.command("list").description("List all channels").action(async () => {
+  try {
+    const channels = await runChannelList();
+    if (channels.length === 0) {
+      console.log(
+        "No channels yet. Create one with: npx zooid channel create <name>"
+      );
+    } else {
+      for (const ch of channels) {
+        const visibility = ch.is_public ? "public" : "private";
+        console.log(
+          `  ${ch.id} \u2014 ${ch.name} (${visibility}, ${ch.event_count} events)`
+        );
+      }
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+channelCmd.command("add-publisher <channel>").description("Add a publisher to a channel").requiredOption("--name <name>", "Publisher name").action(async (channel, opts) => {
+  try {
+    const result = await runChannelAddPublisher(channel, opts.name);
+    printSuccess(`Added publisher: ${result.name}`);
+    printInfo("Publisher ID", result.id);
+    printInfo("Publish token", result.publish_token);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("publish <channel>").description("Publish an event to a channel").option("--type <type>", "Event type").option("--data <json>", "Event data as JSON string").option("--file <path>", "Read event from JSON file").action(async (channel, opts) => {
+  setTelemetryChannel(channel);
+  try {
+    const event = await runPublish(channel, opts);
+    printSuccess(`Published event: ${event.id}`);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+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",
+  "auto"
+).option("--interval <ms>", "Poll interval in ms for follow mode", "5000").action(async (channel, opts) => {
+  setTelemetryChannel(channel);
+  try {
+    if (opts.follow) {
+      const mode = opts.mode;
+      const transport = mode === "auto" ? "auto (WebSocket \u2192 poll fallback)" : mode;
+      console.log(
+        `Tailing ${channel} [${transport}]${opts.type ? ` type=${opts.type}` : ""}...`
+      );
+      console.log("Press Ctrl+C to stop.\n");
+      await runTail(channel, {
+        follow: true,
+        mode,
+        interval: parseInt(opts.interval, 10),
+        type: opts.type
+      });
+    } else {
+      const result = await runTail(channel, {
+        limit: parseInt(opts.limit, 10),
+        type: opts.type,
+        since: opts.since,
+        cursor: opts.cursor
+      });
+      if (result.events.length === 0) {
+        console.log("No events.");
+      } else {
+        for (const event of result.events) {
+          console.log(JSON.stringify(event));
+        }
+      }
+      if (result.cursor) {
+        printInfo("Cursor", result.cursor);
+      }
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("subscribe <channel>").description("Subscribe to a channel").option("--webhook <url>", "Register a webhook instead of polling").option("--interval <ms>", "Poll interval in milliseconds", "5000").option("--mode <mode>", "Transport mode: auto, ws, or poll", "auto").option("--type <type>", "Filter events by type").action(async (channel, opts) => {
+  setTelemetryChannel(channel);
+  try {
+    if (opts.webhook) {
+      const wh = await runSubscribeWebhook(channel, opts.webhook);
+      printSuccess(`Registered webhook: ${wh.id}`);
+      printInfo("URL", wh.url);
+      printInfo("Expires", wh.expires_at);
+    } else {
+      const mode = opts.mode;
+      const transport = mode === "auto" ? "auto (WebSocket \u2192 poll fallback)" : mode;
+      console.log(
+        `Subscribing to ${channel} [${transport}]${opts.type ? ` type=${opts.type}` : ""}...`
+      );
+      console.log("Press Ctrl+C to stop.\n");
+      await runSubscribePoll(channel, {
+        interval: parseInt(opts.interval, 10),
+        mode,
+        type: opts.type
+      });
+      await new Promise(() => {
+      });
+    }
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+var serverCmd = program.command("server").description("Manage server metadata");
+serverCmd.command("get").description("Show server metadata").action(async () => {
+  try {
+    const meta = await runServerGet();
+    console.log(`
+  ${meta.name}
+`);
+    if (meta.description) printInfo("Description", meta.description);
+    if (meta.tags.length > 0) printInfo("Tags", meta.tags.join(", "));
+    if (meta.owner) printInfo("Owner", meta.owner);
+    if (meta.company) printInfo("Company", meta.company);
+    if (meta.email) printInfo("Email", meta.email);
+    printInfo("Updated", meta.updated_at);
+    console.log("");
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+serverCmd.command("set").description("Update server metadata").option("--name <name>", "Server name").option("--description <desc>", "Server description").option("--tags <tags>", "Comma-separated tags").option("--owner <owner>", "Server owner").option("--company <company>", "Company name").option("--email <email>", "Contact email").action(async (opts) => {
+  try {
+    const fields = {};
+    if (opts.name !== void 0) fields.name = opts.name;
+    if (opts.description !== void 0) fields.description = opts.description;
+    if (opts.tags !== void 0)
+      fields.tags = opts.tags.split(",").map((t) => t.trim());
+    if (opts.owner !== void 0) fields.owner = opts.owner;
+    if (opts.company !== void 0) fields.company = opts.company;
+    if (opts.email !== void 0) fields.email = opts.email;
+    if (Object.keys(fields).length === 0) {
+      printError(
+        "No fields specified. Use --name, --description, --tags, --owner, --company, or --email."
+      );
+      process.exit(1);
+    }
+    const meta = await runServerSet(fields);
+    printSuccess(`Updated server metadata`);
+    printInfo("Name", meta.name);
+    console.log("");
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("status").description("Check server status").action(async () => {
+  try {
+    const { discovery, identity } = await runStatus();
+    console.log(`
+  ${identity.name} v${discovery.version}
+`);
+    printInfo("Server ID", discovery.server_id);
+    printInfo("Algorithm", discovery.algorithm);
+    printInfo("Poll interval", `${discovery.poll_interval}s`);
+    printInfo("Delivery", discovery.delivery.join(", "));
+    console.log("");
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("share [channels...]").description("List channels in the Zooid Directory").option("--channel <id>", "Channel to share (alternative to positional args)").option("-y, --yes", "Skip prompts, use server values for description/tags").action(async (channels, opts) => {
+  try {
+    const ids = opts.channel ? [opts.channel, ...channels] : channels;
+    await runShare(ids, { yes: opts.yes });
+    printSuccess("Channels shared to directory");
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("discover").description("Browse public channels in the Zooid Directory").option("-q, --query <text>", "Search by keyword").option("-t, --tag <tag>", "Filter by tag").option("-n, --limit <n>", "Max results", "20").action(async (opts) => {
+  try {
+    await runDiscover({
+      query: opts.query,
+      tag: opts.tag,
+      limit: parseInt(opts.limit, 10)
+    });
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.command("unshare <channel>").description("Remove a channel from the Zooid Directory").action(async (channel) => {
+  try {
+    await runUnshare(channel);
+    printSuccess(`Removed ${channel} from directory`);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+program.parse();
+export {
+  setTelemetryChannel
+};