@glassanalytics/cli 0.0.0-stage → 0.2.0

package/dist/glass.js

@@ -0,0 +1,1222 @@
+#!/usr/bin/env node
+
+// packages/cli/src/index.ts
+import { parseArgs } from "node:util";
+import { GLASS_VERSION as GLASS_VERSION3 } from "@glassanalytics/core/version";
+
+// packages/cli/src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+var GLASS_DIR = ".glass";
+function projectRoot(start = process.cwd()) {
+  let dir = resolve(start);
+  let pkg = null;
+  for (; ; ) {
+    if (existsSync(join(dir, GLASS_DIR, "config.json"))) return dir;
+    if (!pkg && existsSync(join(dir, "package.json"))) pkg = dir;
+    const parent = dirname(dir);
+    if (parent === dir) return pkg ?? resolve(start);
+    dir = parent;
+  }
+}
+function glassDir(root = projectRoot()) {
+  return join(root, GLASS_DIR);
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function loadConfig(root = projectRoot()) {
+  return readJson(join(glassDir(root), "config.json"));
+}
+function saveConfig(config, root = projectRoot()) {
+  writeJson(join(glassDir(root), "config.json"), config);
+}
+function loadCredentials(root = projectRoot()) {
+  return readJson(join(glassDir(root), "credentials.json"));
+}
+function saveCredentials(credentials, root = projectRoot()) {
+  const dir = glassDir(root);
+  writeJson(join(dir, "credentials.json"), credentials);
+  writeFileSync(join(dir, ".gitignore"), "credentials.json\n");
+}
+function connection() {
+  const config = loadConfig();
+  const credentials = loadCredentials();
+  const host = process.env.GLASS_HOST ?? config?.host;
+  const key2 = process.env.GLASS_API_KEY ?? credentials?.adminKey;
+  if (!host || !key2) {
+    throw new UsageError(
+      "No Glass deployment found here.",
+      "Run `npx @glassanalytics/cli init` in your project, or set GLASS_HOST and GLASS_API_KEY."
+    );
+  }
+  return { host: host.replace(/\/+$/, ""), key: key2, project: process.env.GLASS_PROJECT ?? config?.project };
+}
+var UsageError = class extends Error {
+  hint;
+  constructor(message, hint) {
+    super(message);
+    this.name = "UsageError";
+    this.hint = hint;
+  }
+};
+
+// packages/cli/src/client.ts
+async function call(method, path, body, options = {}) {
+  const conn = options.host && options.key ? { host: options.host, key: options.key } : connection();
+  const res = await (options.fetcher ?? fetch)(`${conn.host}${path}`, {
+    method,
+    headers: { Authorization: `Bearer ${conn.key}`, ...body === void 0 ? {} : { "Content-Type": "application/json" } },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  }).catch((err) => {
+    throw new UsageError(`Could not reach ${conn.host}: ${err instanceof Error ? err.message : String(err)}`, "Check your network, or run `glass status`.");
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new UsageError(data.error ?? `HTTP ${res.status}`, data.hint);
+  return data;
+}
+function withProject(value) {
+  const project = value.project ?? connection().project;
+  return project ? { ...value, project } : value;
+}
+
+// packages/cli/src/output.ts
+var useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+var wrap = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var color = {
+  bold: wrap(1),
+  dim: wrap(2),
+  green: wrap(32),
+  red: wrap(31),
+  yellow: wrap(33),
+  cyan: wrap(36)
+};
+function line(text = "") {
+  process.stdout.write(`${text}
+`);
+}
+function ok(text) {
+  line(`${color.green("\u2713")} ${text}`);
+}
+function skip(text) {
+  line(`${color.yellow("\u2013")} ${text}`);
+}
+function fail(text) {
+  process.stderr.write(`${color.red("\u2717")} ${text}
+`);
+}
+function printJson(value) {
+  line(JSON.stringify(value, null, 2));
+}
+function table(headers, rows) {
+  const cells = rows.map((r) => r.map((c) => String(c)));
+  const widths = headers.map((h, i) => Math.min(60, Math.max(h.length, ...cells.map((r) => (r[i] ?? "").length))));
+  const numeric = headers.map((_, i) => rows.length > 0 && rows.every((r) => typeof r[i] === "number"));
+  const fmt = (values) => values.map((v, i) => {
+    const text = v.length > widths[i] ? `${v.slice(0, widths[i] - 1)}\u2026` : v;
+    return numeric[i] ? text.padStart(widths[i]) : text.padEnd(widths[i]);
+  }).join("  ").trimEnd();
+  line(color.dim(fmt(headers)));
+  for (const r of cells) line(fmt(r));
+}
+function pct(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+
+// packages/cli/src/commands/data.ts
+var str = (v) => typeof v === "string" ? v : void 0;
+function showSql(sql2, flags2) {
+  if (!flags2.sql || !sql2) return;
+  line();
+  for (const q of sql2) line(color.dim(q));
+}
+function specFromFlags(kind, flags2) {
+  if (typeof flags2.spec === "string") {
+    try {
+      return JSON.parse(flags2.spec);
+    } catch {
+      throw new UsageError("--spec is not valid JSON.");
+    }
+  }
+  const common = { from: str(flags2.from), to: str(flags2.to), breakdown: str(flags2.breakdown) };
+  const filters = typeof flags2.where === "string" ? flags2.where.split(",").map((w) => {
+    const [property, value] = w.split("=");
+    if (!property || value === void 0) throw new UsageError(`--where expects property=value pairs, got "${w}".`);
+    return { property: property.trim(), value: value.trim() };
+  }) : void 0;
+  switch (kind) {
+    case "web":
+      return { from: common.from, to: common.to, filters };
+    case "trends": {
+      const events2 = str(flags2.event)?.split(",") ?? [];
+      if (!events2.length) throw new UsageError("`glass query trends` needs --event <name>[,<name>\u2026]");
+      return { ...common, filters, interval: str(flags2.interval), series: events2.map((event) => ({ event, math: str(flags2.math), property: str(flags2.property) })) };
+    }
+    case "funnel": {
+      const steps = str(flags2.steps)?.split(",") ?? [];
+      if (steps.length < 2) throw new UsageError("`glass query funnel` needs --steps a,b[,c\u2026]");
+      return { ...common, filters, window: str(flags2.window), steps: steps.map((event) => ({ event: event.trim() })) };
+    }
+    case "retention": {
+      const cohort = str(flags2.cohort);
+      if (!cohort) throw new UsageError("`glass query retention` needs --cohort <event> (and optionally --return <event>)");
+      return {
+        from: common.from,
+        to: common.to,
+        filters,
+        cohortEvent: { event: cohort },
+        returnEvent: { event: str(flags2.return) ?? cohort },
+        period: str(flags2.period),
+        periods: flags2.periods ? Number(flags2.periods) : void 0
+      };
+    }
+    default:
+      throw new UsageError(`Unknown query "${kind}".`, "Use web, trends, funnel or retention (or `glass sql`).");
+  }
+}
+async function query(kind, flags2) {
+  if (!kind) throw new UsageError("Which query?", "glass query web|trends|funnel|retention [options]; see `glass help query`.");
+  const result = await call("POST", "/api/query", withProject({ kind, ...specFromFlags(kind, flags2), project: str(flags2.project) }));
+  if (flags2.json) return printJson(result);
+  line(color.bold(result.summary));
+  line();
+  if (kind === "web") {
+    const r = result;
+    table(["Metric", "Value", "Previous"], [
+      ["Visitors", r.totals.visitors, r.previous?.visitors ?? 0],
+      ["Pageviews", r.totals.pageviews, r.previous?.pageviews ?? 0],
+      ["Sessions", r.totals.sessions, r.previous?.sessions ?? 0],
+      ["Bounce rate", pct(r.totals.bounceRate), r.previous ? pct(r.previous.bounceRate) : "\u2013"]
+    ]);
+    line();
+    table(["Top page", "Visitors"], r.breakdowns.pages.slice(0, 8).map((p) => [p.value, p.visitors]));
+    line();
+    table(["Referrer", "Visitors"], r.breakdowns.referrers.slice(0, 8).map((p) => [p.value, p.visitors]));
+  } else if (kind === "trends") {
+    const r = result;
+    table(["Series", "Total"], r.series.map((s) => [s.label, s.total]));
+  } else if (kind === "funnel") {
+    const r = result;
+    table(["Step", "People", "From start", "From previous"], r.steps.map((s) => [s.label, s.count, pct(s.conversionFromStart), pct(s.conversionFromPrevious)]));
+  } else if (kind === "retention") {
+    const r = result;
+    table(
+      ["Cohort", "People", ...r.average.map((_, k) => `${r.period[0]}${k}`)],
+      r.cohorts.map((c) => [new Date(c.start).toISOString().slice(0, 10), c.size, ...c.rates.map((x) => `${Math.round(x * 100)}%`)])
+    );
+  }
+  line();
+  line(color.dim(`Open in dashboard: ${result.dashboard}`));
+  showSql(result.sql, flags2);
+}
+async function sql(statement, flags2) {
+  if (!statement) throw new UsageError('Pass a query: glass sql "SELECT event, COUNT(*) AS n FROM events GROUP BY event"');
+  const r = await call("POST", "/api/sql", withProject({ query: statement, limit: flags2.limit ? Number(flags2.limit) : void 0, project: str(flags2.project) }));
+  if (flags2.json) return printJson(r);
+  table(r.columns, r.rows.map((row) => r.columns.map((c) => typeof row[c] === "number" ? row[c] : String(row[c] ?? ""))));
+  line(color.dim(r.summary));
+}
+async function events(name, flags2) {
+  const project = str(flags2.project);
+  if (name && typeof flags2.describe === "string") {
+    const r2 = await call("PUT", `/api/events/${encodeURIComponent(name)}`, withProject({ description: flags2.describe, project }));
+    return flags2.json ? printJson(r2) : line(`Saved the description of "${name}".`);
+  }
+  if (name) {
+    const q = project ? `?project=${encodeURIComponent(project)}` : "";
+    const r2 = await call("GET", `/api/events/${encodeURIComponent(name)}${q}`);
+    if (flags2.json) return printJson(r2);
+    line(color.bold(r2.summary));
+    if (r2.description) line(r2.description);
+    line();
+    if (r2.properties.length) table(["Property", "Type", "Coverage", "Examples"], r2.properties.map((p) => [p.name, p.types.join("|"), pct(p.coverage), p.examples.join(", ")]));
+    return;
+  }
+  const r = await call(
+    "GET",
+    `/api/events?days=${Number(flags2.days ?? 30)}${project ? `&project=${encodeURIComponent(project)}` : ""}`
+  );
+  if (flags2.json) return printJson(r);
+  line(color.bold(r.summary));
+  line();
+  table(["Event", "Count", "Last seen", "Description"], r.events.map((e) => [e.event, e.count, e.lastSeen.slice(0, 16).replace("T", " "), e.description]));
+}
+async function person(id, flags2) {
+  if (!id) throw new UsageError("Pass a person id: glass person <user-id>");
+  const q = str(flags2.project) ? `?project=${encodeURIComponent(str(flags2.project))}` : "";
+  if (flags2.delete) {
+    const r2 = await call("DELETE", `/api/persons/${encodeURIComponent(id)}${q}`);
+    return flags2.json ? printJson(r2) : line(r2.summary);
+  }
+  const r = await call("GET", `/api/persons/${encodeURIComponent(id)}${q}`);
+  if (flags2.json) return printJson(r);
+  line(color.bold(r.summary));
+  for (const [k, v] of Object.entries(r.properties)) line(`  ${k}: ${JSON.stringify(v)}`);
+  line();
+  table(["Time", "Event", "Page"], r.recentEvents.slice(0, 25).map((e) => [e.time.slice(0, 19).replace("T", " "), e.event, e.path]));
+}
+async function replays(sub, arg, flags2) {
+  const project = str(flags2.project);
+  if (sub === "summary" || sub === "show") {
+    if (!arg) throw new UsageError("Pass a session id: glass replays summary <session>");
+    const r2 = await call("GET", `/api/replays/${encodeURIComponent(arg)}/summary${project ? `?project=${project}` : ""}`);
+    return flags2.json ? printJson(r2) : line(r2.transcript);
+  }
+  const params = new URLSearchParams();
+  if (project) params.set("project", project);
+  if (flags2.errors) params.set("with_errors", "true");
+  if (typeof flags2.person === "string") params.set("person", flags2.person);
+  const r = await call("GET", `/api/replays?${params}`);
+  if (flags2.json) return printJson(r);
+  line(color.bold(r.summary));
+  line();
+  table(["Session", "Started", "Person", "Seconds", "Errors", "First page"], r.replays.map((x) => [x.session, x.started.slice(0, 16).replace("T", " "), x.person, x.durationSeconds, x.errors, x.url]));
+}
+async function projects(sub, arg, flags2) {
+  if (sub === "add") {
+    if (!arg) throw new UsageError("Pass an id: glass projects add <id>");
+    const r2 = await call("POST", "/api/projects", { id: arg, name: str(flags2.name) });
+    return flags2.json ? printJson(r2) : line(r2.summary);
+  }
+  const r = await call("GET", "/api/projects");
+  if (flags2.json) return printJson(r);
+  table(["Project", "Name"], r.projects.map((p) => [p.id, p.name]));
+}
+
+// packages/cli/src/commands/flags.ts
+var str2 = (v) => typeof v === "string" ? v : void 0;
+var projectQuery = (flags2) => str2(flags2.project) ? `?project=${encodeURIComponent(str2(flags2.project))}` : "";
+async function flags(sub, key2, flags2) {
+  if (!sub || sub === "list") {
+    const r = await call("GET", `/api/flags${projectQuery(flags2)}`);
+    if (flags2.json) return printJson(r);
+    if (!r.flags.length) return line("No flags yet. Create one: glass flags set new-checkout --rollout 10");
+    table(["Flag", "On", "Rollout", "Variants"], r.flags.map((f) => [f.key, f.enabled ? "yes" : "no", `${f.rollout}%`, (f.variants ?? []).map((v) => v.key).join(", ")]));
+    return;
+  }
+  if (!key2) throw new UsageError(`Pass a flag key: glass flags ${sub} <key>`);
+  if (sub === "delete") {
+    const r = await call("DELETE", `/api/flags/${encodeURIComponent(key2)}${projectQuery(flags2)}`);
+    return flags2.json ? printJson(r) : line(r.summary);
+  }
+  if (sub === "set") {
+    const body = { project: str2(flags2.project) };
+    if (flags2.rollout !== void 0) body.rollout = Number(flags2.rollout);
+    if (flags2.enable) body.enabled = true;
+    if (flags2.disable) body.enabled = false;
+    if (typeof flags2.description === "string") body.description = flags2.description;
+    if (typeof flags2.variants === "string") {
+      body.variants = flags2.variants.split(",").map((v) => {
+        const [k, w] = v.split(":");
+        return { key: k.trim(), weight: Number(w ?? 1) };
+      });
+    }
+    if (typeof flags2.rules === "string") body.rules = JSON.parse(flags2.rules);
+    const r = await call("PUT", `/api/flags/${encodeURIComponent(key2)}`, withProject(body));
+    return flags2.json ? printJson(r) : line(r.summary);
+  }
+  throw new UsageError(`Unknown subcommand "flags ${sub}".`, "Use: glass flags [list | set <key> | delete <key>]");
+}
+async function experiments(sub, key2, rest, flags2) {
+  if (!sub || sub === "list") {
+    const r = await call("GET", `/api/experiments${projectQuery(flags2)}`);
+    if (flags2.json) return printJson(r);
+    if (!r.experiments.length) return line("No experiments yet. Create one: glass experiments create pricing-v2 --goal signup_completed");
+    table(["Experiment", "Status", "Goal"], r.experiments.map((e) => [e.key, e.status, e.goal.event]));
+    return;
+  }
+  if (!key2) throw new UsageError(`Pass an experiment key: glass experiments ${sub} <key>`);
+  if (sub === "create") {
+    const goal = str2(flags2.goal);
+    if (!goal) throw new UsageError("Pass the goal event: --goal signup_completed");
+    const r = await call(
+      "POST",
+      "/api/experiments",
+      withProject({ key: key2, goal: { event: goal, value: str2(flags2.value) }, flag: str2(flags2.flag), hypothesis: str2(flags2.hypothesis), project: str2(flags2.project) })
+    );
+    return flags2.json ? printJson(r) : line(r.summary);
+  }
+  if (sub === "start" || sub === "stop" || sub === "ship") {
+    const variant = rest[0] ?? str2(flags2.variant);
+    if (sub === "ship" && !variant) throw new UsageError("Pass the variant to ship: glass experiments ship <key> <variant>");
+    const r = await call("POST", `/api/experiments/${encodeURIComponent(key2)}/${sub}`, withProject({ variant, project: str2(flags2.project) }));
+    return flags2.json ? printJson(r) : line(r.summary);
+  }
+  if (sub === "results" || sub === "show") {
+    const r = await call("GET", `/api/experiments/${encodeURIComponent(key2)}${projectQuery(flags2)}`);
+    if (flags2.json) return printJson(r);
+    line(color.bold(r.summary));
+    line();
+    table(
+      ["Variant", "Exposed", "Converted", "Rate", "P(beat control)"],
+      r.results.variants.map((v) => [v.variant, v.exposures, v.conversions, pct(v.conversionRate), v.vsControl ? pct(v.vsControl.probabilityToBeatControl) : "control"])
+    );
+    return;
+  }
+  throw new UsageError(`Unknown subcommand "experiments ${sub}".`, "Use: glass experiments [list | create | start | stop | ship | results]");
+}
+
+// packages/cli/src/commands/init.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join5 } from "node:path";
+import { randomToken } from "@glassanalytics/core/ids";
+import { FRAMEWORKS, detectFramework } from "@glassanalytics/core/instrument";
+import { GLASS_VERSION as GLASS_VERSION2 } from "@glassanalytics/core/version";
+
+// packages/cli/src/agent-files.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { EVENT_NAMING_GUIDE } from "@glassanalytics/core/instrument";
+var START = "<!-- glass:start -->";
+var END = "<!-- glass:end -->";
+function agentsSection(o) {
+  return `${START}
+## Analytics (Glass)
+
+This project uses Glass for analytics, session replay, feature flags and A/B tests. It runs in our own Cloudflare account; deployment config is in \`.glass/\`.
+
+- Dashboard: ${o.host}/app (print the key with \`npx @glassanalytics/cli key\`)
+- MCP server \`glass\` is configured in \`.mcp.json\`. Start with the \`overview\` tool, then \`list_events\` for exact event names.
+- Terminal: \`npx @glassanalytics/cli query web --from -7d\`, \`npx @glassanalytics/cli sql "SELECT \u2026"\`, \`npx @glassanalytics/cli --help\`
+
+Tracking (project \`${o.project}\`):
+- Install (${o.snippet.file}): \`${o.snippet.code.split("\n").pop()}\`
+- Custom events: \`glass.capture('signup_completed', { plan: 'pro' })\`. After login: \`glass.identify(user.id, { plan })\`.
+- ${EVENT_NAMING_GUIDE}
+- After adding an event and deploying, confirm it arrives: \`npx @glassanalytics/cli events <name>\`. Document it: \`npx @glassanalytics/cli events <name> --describe "\u2026"\`.
+- Feature flags: \`glass.flag('key')\` returns "on", a variant key, or null. Create with \`npx @glassanalytics/cli flags set <key> --rollout 10\`.
+${END}`;
+}
+function upsertSection(path, section, createIfMissing) {
+  const exists = existsSync2(path);
+  if (!exists && !createIfMissing) return false;
+  const current = exists ? readFileSync2(path, "utf8") : "";
+  const pattern = new RegExp(`${START}[\\s\\S]*?${END}`);
+  const next = pattern.test(current) ? current.replace(pattern, section) : `${current.trimEnd()}${current.trim() ? "\n\n" : ""}${section}
+`;
+  writeFileSync2(path, next);
+  return true;
+}
+function skillFile(o) {
+  return `---
+name: glass
+description: Use when adding analytics events, answering questions about traffic, signups, conversion, retention or errors, debugging what a user did in a session, or creating feature flags and A/B tests in this project.
+---
+
+# Glass analytics
+
+Glass is deployed at ${o.host} (project \`${o.project}\`). Prefer the \`glass\` MCP tools; the CLI (\`npx @glassanalytics/cli \u2026\`) does the same things.
+
+## Answer a question about usage
+
+1. \`overview\` for the period (visitors, top pages, errors, events that moved).
+2. \`list_events\` to get exact event names \u2014 never guess them.
+3. The right query: \`query_trends\` (counts over time), \`query_funnel\` (conversion through steps), \`query_retention\` (who comes back), \`sql\` when nothing else fits.
+4. Report numbers with the dashboard link and SQL from the result.
+
+## Add tracking
+
+1. \`instrument\` with the event name returns the exact code for this framework.
+2. ${EVENT_NAMING_GUIDE}
+3. After deploying, \`describe_event\` (or \`npx @glassanalytics/cli events <name>\`) confirms events arrive with the expected properties.
+4. \`define_event\` documents what the event means.
+
+## Debug a user problem
+
+1. \`query_funnel\` with a breakdown (browser, device, utm_source) to find where people drop.
+2. \`list_replays\` with \`with_errors: true\` (or a \`person\`) to find affected sessions.
+3. \`summarise_replay\` to read what happened: pages, labelled clicks, rage clicks, errors.
+
+## Run an experiment
+
+1. \`create_experiment\` with a goal event (creates a control/test flag).
+2. In code: \`if (glass.flag('<key>') === 'test') { \u2026 }\` \u2014 reading the flag records the exposure.
+3. \`update_experiment\` with \`action: "start"\`; later \`experiment_results\`; ship the winner with \`action: "ship"\`.
+`;
+}
+function upsertMcpConfig(path) {
+  let config = {};
+  if (existsSync2(path)) {
+    try {
+      config = JSON.parse(readFileSync2(path, "utf8"));
+    } catch {
+      return false;
+    }
+  }
+  config.mcpServers = { ...config.mcpServers, glass: { command: "npx", args: ["-y", "@glassanalytics/cli", "mcp"] } };
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(config, null, 2)}
+`);
+  return true;
+}
+function writeAgentFiles(o) {
+  const written = [];
+  const section = agentsSection(o);
+  if (upsertSection(join2(o.root, "AGENTS.md"), section, true)) written.push("AGENTS.md");
+  if (upsertSection(join2(o.root, "CLAUDE.md"), section, false)) written.push("CLAUDE.md");
+  const skill = join2(o.root, ".claude", "skills", "glass", "SKILL.md");
+  mkdirSync2(dirname2(skill), { recursive: true });
+  writeFileSync2(skill, skillFile(o));
+  written.push(".claude/skills/glass/SKILL.md");
+  if (upsertMcpConfig(join2(o.root, ".mcp.json"))) written.push(".mcp.json");
+  if (existsSync2(join2(o.root, ".cursor")) && upsertMcpConfig(join2(o.root, ".cursor", "mcp.json"))) written.push(".cursor/mcp.json");
+  return written;
+}
+
+// packages/cli/src/cloudflare/provision.ts
+import { copyFileSync, mkdirSync as mkdirSync3, readdirSync, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+import { LAKE_TABLES, streamSchemaFile } from "@glassanalytics/core/lake";
+
+// packages/cli/src/cloudflare/wrangler.ts
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+var WranglerError = class extends Error {
+  result;
+  args;
+  constructor(args, result) {
+    const output = `${result.stderr}
+${result.stdout}`.trim().split("\n").slice(-12).join("\n");
+    super(`wrangler ${args.slice(0, 3).join(" ")} failed:
+${output}`);
+    this.args = args;
+    this.result = result;
+  }
+  get output() {
+    return `${this.result.stdout}
+${this.result.stderr}`;
+  }
+};
+function wranglerCommand() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    return { cmd: process.execPath, prefix: [require2.resolve("wrangler/bin/wrangler.js")] };
+  } catch {
+    return { cmd: process.platform === "win32" ? "npx.cmd" : "npx", prefix: ["--yes", "wrangler@4"] };
+  }
+}
+function createWrangler(auth, cwd) {
+  const { cmd, prefix } = wranglerCommand();
+  return {
+    run(args, options = {}) {
+      return new Promise((resolve2, reject) => {
+        const child = spawn(cmd, [...prefix, ...args], {
+          cwd,
+          env: {
+            ...process.env,
+            CLOUDFLARE_API_TOKEN: auth.token,
+            CLOUDFLARE_ACCOUNT_ID: auth.accountId,
+            CI: "1",
+            WRANGLER_SEND_METRICS: "false"
+          },
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => {
+          stdout += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+          stderr += d.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolve2({ code: code ?? 1, stdout, stderr }));
+        if (options.input !== void 0) child.stdin.write(options.input);
+        child.stdin.end();
+      });
+    }
+  };
+}
+async function must(wrangler, args, options) {
+  const result = await wrangler.run(args, options);
+  if (result.code !== 0) throw new WranglerError(args, result);
+  return result.stdout;
+}
+function parseJsonOutput(stdout) {
+  const start = stdout.search(/[[{]/);
+  if (start < 0) throw new Error(`Expected JSON from wrangler, got: ${stdout.slice(0, 200)}`);
+  return JSON.parse(stdout.slice(start));
+}
+
+// packages/cli/src/cloudflare/provision.ts
+var isAlreadyExists = (err) => err instanceof WranglerError && /already exists|already own|10004|11009/i.test(err.output);
+var isR2Disabled = (err) => err instanceof WranglerError && /enable R2|R2 (is|has) not been enabled|purchase R2|10042/i.test(err.output);
+async function ensureD1(wrangler, name, eu, report) {
+  const find = async () => parseJsonOutput(await must(wrangler, ["d1", "list", "--json"])).find((db2) => db2.name === name);
+  let db = await find();
+  if (db) {
+    report("ok", `D1 database "${name}"`, "exists");
+  } else {
+    await must(wrangler, ["d1", "create", name, ...eu ? ["--jurisdiction", "eu"] : []]);
+    db = await find();
+    if (!db) throw new Error(`Created D1 database "${name}" but could not find it afterwards.`);
+    report("created", `D1 database "${name}"`);
+  }
+  return { name, id: db.uuid };
+}
+async function ensureBucket(wrangler, bucket, eu, report, purpose) {
+  try {
+    await must(wrangler, ["r2", "bucket", "create", bucket, ...eu ? ["--jurisdiction", "eu"] : []]);
+    report("created", `R2 bucket "${bucket}" for ${purpose}`);
+    return true;
+  } catch (err) {
+    if (isAlreadyExists(err)) {
+      report("ok", `R2 bucket "${bucket}" for ${purpose}`, "exists");
+      return true;
+    }
+    if (isR2Disabled(err)) return false;
+    throw err;
+  }
+}
+async function findByName(wrangler, kind, name) {
+  const args = kind ? ["pipelines", kind, "list", "--json", "--per-page", "100"] : ["pipelines", "list", "--json", "--per-page", "100"];
+  const items = parseJsonOutput(await must(wrangler, args));
+  return items.find((i) => i.name === name);
+}
+async function ensureLake(wrangler, options, report) {
+  if (!await ensureBucket(wrangler, options.bucket, options.eu, report, "event lake")) {
+    throw new Error("Lake mode needs R2. Enable R2 in the Cloudflare dashboard, then run `glass init --lake` again.");
+  }
+  let enabled = false;
+  for (const args of [
+    ["r2", "bucket", "catalog", "enable", options.bucket],
+    ["basin", "catalog", "enable", options.bucket]
+  ]) {
+    const r = await wrangler.run(args);
+    if (r.code === 0 || /already enabled/i.test(r.stdout + r.stderr)) {
+      enabled = true;
+      break;
+    }
+  }
+  if (!enabled) throw new Error(`Could not enable the data catalog on "${options.bucket}". Enable it in the R2 dashboard, then re-run.`);
+  report("ok", `Data catalog on "${options.bucket}"`);
+  const streams = {};
+  for (const table2 of Object.keys(LAKE_TABLES)) {
+    const streamName = LAKE_TABLES[table2].stream;
+    const sinkName = `${streamName}_sink`;
+    let stream = await findByName(wrangler, "streams", streamName);
+    if (!stream) {
+      const schemaPath = join3(options.dir, "schemas", `${table2}.json`);
+      mkdirSync3(join3(options.dir, "schemas"), { recursive: true });
+      writeFileSync3(schemaPath, `${JSON.stringify(streamSchemaFile(table2), null, 2)}
+`);
+      await must(wrangler, ["pipelines", "streams", "create", streamName, "--schema-file", schemaPath, "--http-enabled", "false"]);
+      stream = await findByName(wrangler, "streams", streamName);
+      if (!stream) throw new Error(`Created stream "${streamName}" but could not find it.`);
+      report("created", `Pipelines stream "${streamName}"`);
+    }
+    streams[table2] = stream.id;
+    if (!await findByName(wrangler, "sinks", sinkName)) {
+      await must(wrangler, [
+        "pipelines",
+        "sinks",
+        "create",
+        sinkName,
+        "--type",
+        "r2-data-catalog",
+        "--bucket",
+        options.bucket,
+        "--namespace",
+        options.namespace,
+        "--table",
+        table2,
+        "--catalog-token",
+        options.token,
+        "--roll-interval",
+        "60"
+      ]);
+      report("created", `Iceberg table "${options.namespace}.${table2}"`);
+    }
+    if (!await findByName(wrangler, null, streamName)) {
+      await must(wrangler, ["pipelines", "create", streamName, "--sql", `INSERT INTO ${sinkName} SELECT * FROM ${streamName}`]);
+      report("created", `Pipeline "${streamName}"`);
+    }
+  }
+  return { bucket: options.bucket, namespace: options.namespace, streams };
+}
+function renderWranglerConfig(config) {
+  const vars = { GLASS_STORE: config.store };
+  if (config.lake) {
+    vars.LAKE_BUCKET = config.lake.bucket;
+    vars.LAKE_NAMESPACE = config.lake.namespace;
+    vars.CF_ACCOUNT_ID = config.accountId;
+  }
+  if (config.route) vars.GLASS_PUBLIC_URL = `https://${config.route.replace(/\/\*$/, "")}`;
+  const wrangler = {
+    name: config.name,
+    main: "worker.js",
+    compatibility_date: "2026-10-01",
+    workers_dev: true,
+    d1_databases: [{ binding: "DB", database_name: config.d1.name, database_id: config.d1.id, migrations_dir: "migrations" }],
+    vars,
+    triggers: { crons: ["17 3 * * *"] },
+    observability: { enabled: true }
+  };
+  if (config.replay) wrangler.r2_buckets = [{ binding: "REPLAYS", bucket_name: config.replay.bucket }];
+  if (config.lake) {
+    wrangler.pipelines = [
+      { binding: "EVENTS_STREAM", stream: config.lake.streams.events },
+      { binding: "IDENTITIES_STREAM", stream: config.lake.streams.identities }
+    ];
+  }
+  if (config.route) {
+    const zone = config.route.split("/")[0].split(".").slice(-2).join(".");
+    wrangler.routes = [{ pattern: config.route, zone_name: zone }];
+  }
+  return `// Generated by \`glass\`. Edit .glass/config.json and run \`glass upgrade\` instead of editing this file.
+${JSON.stringify(wrangler, null, 2)}
+`;
+}
+function installWorkerFiles(dir, bundleDir) {
+  mkdirSync3(join3(dir, "migrations"), { recursive: true });
+  copyFileSync(join3(bundleDir, "worker.js"), join3(dir, "worker.js"));
+  for (const file of readdirSync(join3(bundleDir, "migrations"))) {
+    copyFileSync(join3(bundleDir, "migrations", file), join3(dir, "migrations", file));
+  }
+}
+async function deploy(wrangler, configPath) {
+  const out = await must(wrangler, ["deploy", "--config", configPath]);
+  return /https:\/\/[\w.-]+\.workers\.dev/.exec(out)?.[0] ?? null;
+}
+async function migrate(wrangler, database, configPath) {
+  await must(wrangler, ["d1", "migrations", "apply", database, "--remote", "--config", configPath]);
+}
+async function putSecrets(wrangler, secrets, configPath, dir) {
+  const file = join3(dir, ".secrets.tmp.json");
+  writeFileSync3(file, JSON.stringify(secrets), { mode: 384 });
+  try {
+    await must(wrangler, ["secret", "bulk", file, "--config", configPath]);
+  } finally {
+    rmSync(file, { force: true });
+  }
+}
+async function listAccounts(token, fetcher = fetch) {
+  const res = await fetcher("https://api.cloudflare.com/client/v4/accounts?per_page=50", { headers: { Authorization: `Bearer ${token}` } });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.success) {
+    throw new Error(`Cloudflare rejected the API token: ${body.errors?.[0]?.message ?? `HTTP ${res.status}`}`);
+  }
+  return body.result ?? [];
+}
+var TOKEN_SCOPES = [
+  "Account \u203A Workers Scripts \u203A Edit",
+  "Account \u203A D1 \u203A Edit",
+  "Account \u203A Workers R2 Storage \u203A Edit",
+  "Account \u203A Account Settings \u203A Read",
+  "Zone \u203A Workers Routes \u203A Edit (only with --route)",
+  "Account \u203A Pipelines \u203A Edit, Workers R2 Data Catalog \u203A Edit, Workers R2 SQL \u203A Read (only with --lake)"
+];
+
+// packages/cli/src/prompt.ts
+import { createInterface } from "node:readline/promises";
+var interactive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+async function ask(question, options) {
+  if (!interactive()) {
+    if (options.default !== void 0) return options.default;
+    throw new UsageError(`Missing ${options.flag}.`, `Pass ${options.flag} (this terminal is not interactive).`);
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  if (options.secret) {
+    const write = rl._writeToOutput.bind(rl);
+    rl._writeToOutput = (s) => write(s.startsWith(question) ? s : "*");
+  }
+  const suffix = options.default ? ` (${options.default})` : "";
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  rl.close();
+  if (options.secret) process.stdout.write("\n");
+  return answer || options.default || "";
+}
+async function choose(question, items, label, flag) {
+  if (items.length === 1) return items[0];
+  if (!interactive()) throw new UsageError(`Several options for ${flag}: ${items.map(label).join(", ")}.`, `Pass ${flag}.`);
+  items.forEach((item2, i) => process.stdout.write(`  ${i + 1}. ${label(item2)}
+`));
+  const answer = Number(await ask(question, { flag, default: "1" }));
+  const item = items[answer - 1];
+  if (!item) throw new UsageError(`Pick a number from 1 to ${items.length}.`);
+  return item;
+}
+
+// packages/cli/src/commands/upgrade.ts
+import { existsSync as existsSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { GLASS_VERSION } from "@glassanalytics/core/version";
+function workerBundleDir() {
+  const candidates = [new URL("./worker/", import.meta.url), new URL("../../../worker/dist/", import.meta.url)];
+  for (const c of candidates) {
+    const dir = fileURLToPath(c);
+    if (existsSync3(join4(dir, "worker.js")) && existsSync3(join4(dir, "migrations"))) return dir;
+  }
+  throw new UsageError("The Worker bundle is missing.", "If you are working on Glass itself, run `pnpm build` first.");
+}
+async function upgrade(options, deps = {}) {
+  const root = projectRoot();
+  const config = loadConfig(root);
+  const credentials = loadCredentials(root);
+  if (!config || !credentials) throw new UsageError("No Glass deployment in this project.", "Run `npx @glassanalytics/cli init` first.");
+  const token = options.token ?? process.env.CLOUDFLARE_API_TOKEN ?? await ask("Cloudflare API token", { flag: "--token (or CLOUDFLARE_API_TOKEN)", secret: true });
+  const wrangler = (deps.wrangler ?? createWrangler)({ token, accountId: config.accountId }, root);
+  const dir = glassDir(root);
+  const report = (status2, label, detail) => {
+    if (options.json) return;
+    (status2 === "skipped" ? skip : ok)(`${label}${detail ? color.dim(` (${detail})`) : ""}`);
+  };
+  if (!config.replay && await ensureBucket(wrangler, `${config.name}-replays`, config.eu, report, "session replay")) {
+    config.replay = { bucket: `${config.name}-replays` };
+  }
+  installWorkerFiles(dir, workerBundleDir());
+  const configPath = join4(dir, "wrangler.jsonc");
+  writeFileSync4(configPath, renderWranglerConfig(config));
+  await migrate(wrangler, config.d1.name, configPath);
+  report("ok", "Migrations applied");
+  await deploy(wrangler, configPath);
+  await putSecrets(
+    wrangler,
+    {
+      GLASS_ADMIN_KEY: credentials.adminKey,
+      GLASS_READ_KEY: credentials.readKey,
+      GLASS_SALT_SECRET: credentials.saltSecret
+      // CF_API_TOKEN (lake mode) is set by init and left alone here, so a narrower token you set stays.
+    },
+    configPath,
+    dir
+  );
+  const from = config.version;
+  config.version = GLASS_VERSION;
+  saveConfig(config, root);
+  if (options.json) printJson({ from, to: GLASS_VERSION, host: config.host, replay: Boolean(config.replay) });
+  else ok(`Glass ${from === GLASS_VERSION ? GLASS_VERSION : `${from} upgraded to ${GLASS_VERSION}`} is live at ${config.host}`);
+}
+async function status(options) {
+  const conn = connection();
+  const config = loadConfig();
+  const health = await call("GET", "/health");
+  const events2 = await call("GET", `/api/events?days=1${conn.project ? `&project=${conn.project}` : ""}`).catch(() => ({ events: [] }));
+  const total = events2.events.reduce((a, e) => a + e.count, 0);
+  const last = events2.events.map((e) => e.lastSeen).sort().at(-1);
+  const mcp = existsSync3(join4(projectRoot(), ".mcp.json"));
+  const result = {
+    host: conn.host,
+    project: conn.project,
+    version: health.version,
+    cliVersion: GLASS_VERSION,
+    store: health.store,
+    replay: health.replay,
+    eventsLast24h: total,
+    lastEvent: last ?? null,
+    mcpConfigured: mcp,
+    upgradeAvailable: health.version !== GLASS_VERSION,
+    account: config?.accountId
+  };
+  if (options.json) return printJson(result);
+  ok(`Worker reachable at ${conn.host} (Glass ${health.version}, ${health.store} store)`);
+  (total ? ok : skip)(total ? `${total.toLocaleString("en-US")} events in the last 24 hours, latest ${last}` : "No events in the last 24 hours. Is the snippet installed?");
+  (health.replay ? ok : skip)(health.replay ? "Session replay enabled" : "Session replay disabled (no R2 bucket); `glass upgrade` retries");
+  (mcp ? ok : skip)(mcp ? "MCP server configured in .mcp.json" : "No .mcp.json; run `glass init` again to write agent files");
+  if (result.upgradeAvailable) skip(`This CLI is Glass ${GLASS_VERSION}; the Worker runs ${health.version}. Run \`glass upgrade\`.`);
+}
+function key(options) {
+  const conn = connection();
+  const credentials = loadCredentials();
+  const value = options.read ? credentials?.readKey : conn.key;
+  if (options.json) return printJson({ host: conn.host, project: conn.project, dashboard: `${conn.host}/app`, key: value });
+  line(`Dashboard: ${conn.host}/app`);
+  line(`${options.read ? "Read-only key" : "Admin key"}: ${value}`);
+  line(color.dim(options.read ? "Safe to share for viewing." : "Full access. Use `glass key --read` for a key that can only view."));
+}
+
+// packages/cli/src/commands/init.ts
+function defaultProjectId(root) {
+  try {
+    const pkg = JSON.parse(readFileSync3(join5(root, "package.json"), "utf8"));
+    const id = (pkg.name ?? "").replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+    if (id) return id.slice(0, 63);
+  } catch {
+  }
+  return "default";
+}
+function readPackageJson(root) {
+  try {
+    return JSON.parse(readFileSync3(join5(root, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function waitForWorker(host, key2, fetcher, pollMs) {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    try {
+      const res = await fetcher(`${host}/api`, { headers: { Authorization: `Bearer ${key2}` } });
+      if (res.ok) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  throw new UsageError(`The Worker at ${host} did not come up.`, "Run `glass status` in a minute; if it persists, `glass upgrade` redeploys.");
+}
+async function init(options, deps = {}) {
+  const root = deps.root ?? projectRoot();
+  const dir = glassDir(root);
+  const fetcher = deps.fetcher ?? fetch;
+  const existing = loadConfig(root);
+  const quiet = Boolean(options.json);
+  const steps = [];
+  const report = (status2, label, detail) => {
+    steps.push({ status: status2, label, detail });
+    if (quiet) return;
+    const text = `${label}${detail ? color.dim(` (${detail})`) : status2 === "created" ? color.dim(" (created)") : ""}`;
+    if (status2 === "skipped") skip(text);
+    else ok(text);
+  };
+  if (!quiet) {
+    line(color.bold("Glass: analytics in your own Cloudflare account"));
+    line();
+  }
+  const token = options.token ?? process.env.CLOUDFLARE_API_TOKEN ?? await ask("Cloudflare API token", { flag: "--token (or CLOUDFLARE_API_TOKEN)", secret: true });
+  if (!token) throw new UsageError("A Cloudflare API token is required.", `Create one at https://dash.cloudflare.com/profile/api-tokens with: ${TOKEN_SCOPES.join("; ")}.`);
+  const accounts = await listAccounts(token, fetcher).catch((err) => {
+    throw new UsageError(err instanceof Error ? err.message : String(err), "Check the token, or create a new one at https://dash.cloudflare.com/profile/api-tokens");
+  });
+  const accountId = options.account ?? process.env.CLOUDFLARE_ACCOUNT_ID ?? existing?.accountId;
+  const account = accountId ? accounts.find((a) => a.id === accountId) ?? { id: accountId, name: accountId } : await choose("Which account?", accounts, (a) => `${a.name} (${a.id})`, "--account");
+  if (!account) throw new UsageError("This token cannot see any Cloudflare accounts.", `Give it account permissions: ${TOKEN_SCOPES.join("; ")}.`);
+  report("ok", `Cloudflare token works (account ${account.name})`);
+  const name = options.name ?? existing?.name ?? "glass";
+  const project = options.project ?? existing?.project ?? defaultProjectId(root);
+  const lake = options.lake ?? existing?.store === "lake";
+  const eu = options.eu ?? existing?.eu ?? false;
+  const route = options.route ?? existing?.route ?? null;
+  const wantReplay = options.replay ?? true;
+  if (options.dryRun) {
+    const plan = {
+      account: account.id,
+      worker: name,
+      project,
+      store: lake ? "lake" : "d1",
+      eu,
+      route,
+      replay: wantReplay,
+      resources: [
+        `D1 database "${name}"`,
+        wantReplay ? `R2 bucket "${name}-replays"` : null,
+        lake ? `R2 bucket "${name}-data" with data catalog, Pipelines streams/sinks for events and identities` : null
+      ].filter(Boolean),
+      files: [".glass/config.json", ".glass/wrangler.jsonc", ".glass/worker.js", ".glass/migrations/", ".glass/credentials.json (git-ignored)", "AGENTS.md", ".claude/skills/glass/SKILL.md", ".mcp.json"]
+    };
+    if (quiet) printJson(plan);
+    else {
+      line();
+      line("Dry run: nothing was changed. This would create:");
+      for (const r of plan.resources) line(`  ${r}`);
+      line(`and deploy Worker "${name}" for project "${project}", writing ${plan.files.join(", ")}.`);
+    }
+    return;
+  }
+  const wrangler = (deps.wrangler ?? createWrangler)({ token, accountId: account.id }, root);
+  try {
+    const d1 = await ensureD1(wrangler, name, eu, report);
+    let replay = null;
+    if (wantReplay) {
+      const bucket = `${name}-replays`;
+      if (await ensureBucket(wrangler, bucket, eu, report, "session replay")) replay = { bucket };
+      else report("skipped", "Session replay", "R2 is not enabled on this account; enable it in the Cloudflare dashboard, then run `glass upgrade`");
+    } else {
+      report("skipped", "Session replay", "disabled with --no-replay");
+    }
+    const lakeConfig = lake ? await ensureLake(wrangler, { bucket: `${name}-data`, namespace: "glass", token, eu, dir }, report) : null;
+    const config = {
+      name,
+      accountId: account.id,
+      host: existing?.host ?? "",
+      project,
+      store: lake ? "lake" : "d1",
+      d1,
+      replay,
+      lake: lakeConfig,
+      route,
+      eu,
+      version: GLASS_VERSION2
+    };
+    const credentials = loadCredentials(root) ?? { adminKey: randomToken(), readKey: randomToken(), saltSecret: randomToken() };
+    installWorkerFiles(dir, deps.bundleDir ?? workerBundleDir());
+    const configPath = join5(dir, "wrangler.jsonc");
+    writeFileSync5(configPath, renderWranglerConfig(config));
+    saveCredentials(credentials, root);
+    await migrate(wrangler, d1.name, configPath);
+    report("ok", "Database migrated");
+    const url = await deploy(wrangler, configPath);
+    config.host = route ? `https://${route.replace(/\/\*$/, "")}` : url ?? config.host;
+    if (!config.host) throw new UsageError("Deployed, but could not read the Worker URL.", "Enable a workers.dev subdomain in the Cloudflare dashboard (Workers & Pages), then run `glass upgrade`.");
+    await putSecrets(
+      wrangler,
+      {
+        GLASS_ADMIN_KEY: credentials.adminKey,
+        GLASS_READ_KEY: credentials.readKey,
+        GLASS_SALT_SECRET: credentials.saltSecret,
+        ...lake ? { CF_API_TOKEN: token } : {}
+      },
+      configPath,
+      dir
+    );
+    saveConfig(config, root);
+    report("ok", `Worker deployed at ${config.host}`);
+    await waitForWorker(config.host, credentials.adminKey, fetcher, deps.pollMs ?? 1500);
+    await call("POST", "/api/projects", { id: project }, { host: config.host, key: credentials.adminKey, fetcher });
+    report("ok", `Project "${project}" ready`);
+    const auth = { host: config.host, key: credentials.adminKey, fetcher };
+    await call("POST", "/e", { project, events: [{ id: randomToken(16), event: "$install_check", ts: Date.now(), distinct_id: "glass-cli" }] }, auth);
+    if (lake) {
+      report("ok", "Test event sent", "the lake shows events within about two minutes");
+    } else {
+      const seen = await call("GET", `/api/events?days=1&project=${encodeURIComponent(project)}`, void 0, auth);
+      if (seen.events.some((e) => e.event === "$install_check")) report("ok", "Test event received");
+      else report("skipped", "Test event not visible yet", "run `glass status` in a minute");
+    }
+    const framework = detectFramework(readPackageJson(root));
+    const snippet = FRAMEWORKS[framework].snippet({ host: config.host, project });
+    const written = options.agentFiles === false ? [] : writeAgentFiles({ root, host: config.host, project, snippet });
+    if (quiet) {
+      printJson({ host: config.host, project, dashboard: `${config.host}/app`, framework, snippet, written, steps });
+      return;
+    }
+    line();
+    line(color.bold(`Next: add Glass to your site (${FRAMEWORKS[framework].name})`));
+    line();
+    line(color.dim(`  ${snippet.file}`));
+    for (const l of snippet.code.split("\n")) line(`  ${l}`);
+    line();
+    line(`Then track what matters: ${color.cyan("glass.capture('signup_completed', { plan: 'pro' })")}`);
+    if (written.length) {
+      line();
+      line(color.bold("Written for your agent"));
+      for (const f of written) line(`  ${f}`);
+      line(`  .glass/ ${color.dim("(deployment config: commit it; credentials.json is git-ignored)")}`);
+    }
+    line();
+    line(`Dashboard: ${color.cyan(`${config.host}/app`)} ${color.dim("(sign in with the key from `npx @glassanalytics/cli key`)")}`);
+  } catch (err) {
+    if (err instanceof WranglerError && /Authentication|not authorized|permission|10000|9109/i.test(err.output)) {
+      throw new UsageError(`Cloudflare refused a request: ${err.message.split("\n")[0]}`, `The API token needs: ${TOKEN_SCOPES.join("; ")}.`);
+    }
+    throw err;
+  }
+}
+
+// packages/cli/src/commands/mcp.ts
+import { createInterface as createInterface2 } from "node:readline";
+async function mcpBridge(options = {}) {
+  const conn = connection();
+  const fetcher = options.fetcher ?? fetch;
+  const output = options.output ?? process.stdout;
+  const rl = createInterface2({ input: options.input ?? process.stdin, crlfDelay: Number.POSITIVE_INFINITY });
+  const pending = [];
+  const send = (message) => output.write(`${JSON.stringify(message)}
+`);
+  const forward = async (lineText) => {
+    let message;
+    try {
+      message = JSON.parse(lineText);
+    } catch {
+      send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+      return;
+    }
+    try {
+      const res = await fetcher(`${conn.host}/mcp`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${conn.key}`, "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+        body: lineText
+      });
+      if (res.status === 202 || message.id === void 0) return;
+      const text = await res.text();
+      if (!res.ok && !text.startsWith("{")) {
+        send({ jsonrpc: "2.0", id: message.id ?? null, error: { code: -32603, message: `Glass returned HTTP ${res.status}: ${text.slice(0, 200)}` } });
+        return;
+      }
+      output.write(`${text.replace(/\n/g, "")}
+`);
+    } catch (err) {
+      send({ jsonrpc: "2.0", id: message.id ?? null, error: { code: -32603, message: `Could not reach ${conn.host}: ${err instanceof Error ? err.message : String(err)}` } });
+    }
+  };
+  for await (const lineText of rl) {
+    if (lineText.trim()) pending.push(forward(lineText));
+  }
+  await Promise.all(pending);
+}
+
+// packages/cli/src/index.ts
+var HELP = `${color.bold("glass")} ${GLASS_VERSION3}: agent-first analytics in your own Cloudflare account
+
+${color.bold("Set up")}
+  glass init                     Deploy Glass and wire it into this project
+    --token <token>                Cloudflare API token (or CLOUDFLARE_API_TOKEN)
+    --account <id>                 Cloudflare account id (or CLOUDFLARE_ACCOUNT_ID)
+    --project <id>                 Project id (default: package.json name)
+    --name <name>                  Worker and resource name (default: glass)
+    --route <host/_glass/*>        Also serve from your domain, e.g. acme.com/_glass/*
+    --lake                         Store events in Iceberg on R2 (Pipelines + Basin SQL)
+    --eu                           Keep data in the EU jurisdiction
+    --no-replay                    Skip session replay storage
+    --no-agent-files               Don't write AGENTS.md, SKILL.md or .mcp.json
+    --dry-run                      Show what would be created
+  glass upgrade                  Redeploy this version of Glass and migrate
+  glass status                   Check the deployment end to end
+  glass key [--read]             Print the dashboard URL and API key
+
+${color.bold("Ask questions")}
+  glass query web [--from -7d]
+  glass query trends --event signup_completed [--math unique_persons] [--interval week] [--breakdown browser]
+  glass query funnel --steps '$pageview,signup_started,signup_completed' [--window 1d] [--breakdown utm_source]
+  glass query retention --cohort signup_completed [--return '$pageview'] [--period week]
+  glass query <kind> --spec '<json>'   Any spec; see GET /api/schema
+    common: --from, --to, --where prop=value[,\u2026], --project, --sql (print SQL)
+  glass sql "SELECT \u2026"           Read-only SQL against your events
+  glass events [name]            Tracked events, or one event's properties
+    --describe "<text>"            Document an event
+  glass person <id> [--delete]   One person's properties and events (or erase them)
+  glass replays [--errors]       Recorded sessions
+  glass replays summary <id>     A session as a text transcript
+
+${color.bold("Flags and experiments")}
+  glass flags [list]
+  glass flags set <key> [--rollout 25] [--variants control:50,test:50] [--enable|--disable] [--rules '<json>']
+  glass flags delete <key>
+  glass experiments [list]
+  glass experiments create <key> --goal <event> [--flag <key>] [--hypothesis "\u2026"]
+  glass experiments start|stop <key>
+  glass experiments ship <key> <variant>
+  glass experiments results <key>
+
+${color.bold("Agents")}
+  glass mcp                      MCP server over stdio (what .mcp.json runs)
+
+Environment: GLASS_HOST, GLASS_API_KEY and GLASS_PROJECT override .glass/ settings.
+Docs: https://github.com/ISNIT0/glass-analytics`;
+var STRING_OPTIONS = [
+  "token",
+  "account",
+  "project",
+  "name",
+  "route",
+  "from",
+  "to",
+  "event",
+  "math",
+  "property",
+  "interval",
+  "breakdown",
+  "steps",
+  "window",
+  "cohort",
+  "return",
+  "period",
+  "periods",
+  "spec",
+  "where",
+  "limit",
+  "days",
+  "describe",
+  "person",
+  "rollout",
+  "variants",
+  "rules",
+  "description",
+  "goal",
+  "flag",
+  "value",
+  "hypothesis",
+  "variant"
+];
+var BOOLEAN_OPTIONS = ["json", "lake", "eu", "no-replay", "no-agent-files", "dry-run", "read", "sql", "errors", "enable", "disable", "delete"];
+async function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: false,
+    options: {
+      ...Object.fromEntries(STRING_OPTIONS.map((o) => [o, { type: "string" }])),
+      ...Object.fromEntries(BOOLEAN_OPTIONS.map((o) => [o, { type: "boolean" }])),
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  const flags2 = values;
+  const [command, sub, arg, ...rest] = positionals;
+  if (flags2.version) return line(GLASS_VERSION3);
+  if (!command || command === "help" || flags2.help && !command) return line(HELP);
+  switch (command) {
+    case "init":
+      return init({
+        token: str3(flags2.token),
+        account: str3(flags2.account),
+        project: str3(flags2.project),
+        name: str3(flags2.name),
+        route: str3(flags2.route),
+        lake: flags2.lake === true ? true : void 0,
+        eu: flags2.eu === true ? true : void 0,
+        replay: flags2["no-replay"] ? false : void 0,
+        agentFiles: flags2["no-agent-files"] ? false : void 0,
+        dryRun: Boolean(flags2["dry-run"]),
+        json: Boolean(flags2.json)
+      });
+    case "upgrade":
+    case "deploy":
+      return upgrade({ token: str3(flags2.token), json: Boolean(flags2.json) });
+    case "status":
+    case "doctor":
+      return status({ json: Boolean(flags2.json) });
+    case "key":
+      return key({ read: Boolean(flags2.read), json: Boolean(flags2.json) });
+    case "query":
+      return query(sub, flags2);
+    case "sql":
+      return sql(sub, flags2);
+    case "events":
+      return events(sub, flags2);
+    case "person":
+    case "persons":
+      return person(sub, flags2);
+    case "replays":
+      return replays(sub, arg, flags2);
+    case "projects":
+      return projects(sub, arg, flags2);
+    case "flags":
+      return flags(sub, arg, flags2);
+    case "experiments":
+      return experiments(sub, arg, rest, flags2);
+    case "mcp":
+      return mcpBridge();
+    default:
+      throw new UsageError(`Unknown command "${command}".`, "Run `glass help` for the list of commands.");
+  }
+}
+function str3(v) {
+  return typeof v === "string" ? v : void 0;
+}
+var invoked = process.argv[1] ?? "";
+if (/glass(\.js)?$|cli[\\/]src[\\/]index\.ts$/.test(invoked)) {
+  main(process.argv.slice(2)).catch((err) => {
+    if (err instanceof UsageError) {
+      fail(err.message);
+      if (err.hint) process.stderr.write(`  ${err.hint}
+`);
+    } else {
+      fail(err instanceof Error ? err.message : String(err));
+      if (process.env.GLASS_DEBUG && err instanceof Error) process.stderr.write(`${err.stack}
+`);
+    }
+    process.exitCode = 1;
+  });
+}
+export {
+  main
+};