@ainyc/canonry 4.14.0 → 4.15.2

package/dist/cli.js

@@ -3,6 +3,7 @@ import {
   coerceAgentProvider,
   computeCompetitorOverlap,
   createServer,
+  detectAndTrackUpgrade,
   determineCitationState,
   extractRecommendedCompetitors,
   formatAuditFactorScore,
@@ -16,9 +17,10 @@ import {
   reparseStoredResult3,
   reparseStoredResult4,
   setGoogleAuthConfig,
+  setTelemetrySource,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-UQHWSCTE.js";
+} from "./chunk-IVNWS2YU.js";
 import {
   CliError,
   EXIT_SYSTEM_ERROR,
@@ -29,11 +31,12 @@ import {
   getConfigPath,
   isEndpointMissing,
   loadConfig,
+  loadConfigRaw,
   printCliError,
   saveConfig,
   saveConfigPatch,
   usageError
-} from "./chunk-5NYG5EC7.js";
+} from "./chunk-7SRKUAZO.js";
 import {
   apiKeys,
   competitors,
@@ -43,9 +46,10 @@ import {
   migrate,
   parseJsonColumn,
   projects,
+  queries,
   querySnapshots,
   runs
-} from "./chunk-7HBZCGRL.js";
+} from "./chunk-MI33SQL6.js";
 import {
   CcReleaseSyncStatuses,
   CheckScopes,
@@ -56,6 +60,7 @@ import {
   RunKinds,
   RunStatuses,
   SkillsClients,
+  TrafficEventKinds,
   determineAnswerMentioned,
   effectiveDomains,
   formatRunErrorOneLine,
@@ -64,11 +69,47 @@ import {
   providerQuotaPolicySchema,
   resolveProviderInput,
   skillsClientSchema
-} from "./chunk-6QTH5NS5.js";
+} from "./chunk-ONI3TX2A.js";
 
 // src/cli.ts
 import { pathToFileURL } from "url";
 
+// src/setup-state.ts
+import fs from "fs";
+function buildSetupState() {
+  if (!configExists()) return void 0;
+  let provider_count = 0;
+  let has_keywords = false;
+  let project_count = 0;
+  let is_first_run = true;
+  let dbPath;
+  try {
+    const raw = loadConfigRaw();
+    if (raw) {
+      is_first_run = !raw.anonymousId;
+      if (raw.providers) {
+        provider_count = Object.values(raw.providers).filter(
+          (p) => Boolean(p?.apiKey) || Boolean(p?.baseUrl)
+        ).length;
+      }
+      if (typeof raw.database === "string" && raw.database.length > 0) {
+        dbPath = raw.database;
+      }
+    }
+  } catch {
+  }
+  if (dbPath && fs.existsSync(dbPath)) {
+    try {
+      const db = createClient(dbPath);
+      project_count = db.select({ id: projects.id }).from(projects).all().length;
+      const firstQuery = db.select({ id: queries.id }).from(queries).limit(1).all();
+      has_keywords = firstQuery.length > 0;
+    } catch {
+    }
+  }
+  return { provider_count, has_keywords, project_count, is_first_run };
+}
+
 // src/cli-dispatch.ts
 import { parseArgs } from "util";
 function commandId(spec) {
@@ -580,7 +621,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService } = await import("./intelligence-service-BCKXIKIL.js");
+  const { IntelligenceService } = await import("./intelligence-service-JYV3CO4H.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -2018,9 +2059,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs12 = await import("fs");
+    const fs13 = await import("fs");
     try {
-      const content = fs12.readFileSync(opts.keyFile, "utf-8");
+      const content = fs13.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -2698,10 +2739,10 @@ async function trafficConnectCloudRun(project, opts) {
       details: { project }
     });
   }
-  const fs12 = await import("fs");
+  const fs13 = await import("fs");
   let keyJson;
   try {
-    keyJson = fs12.readFileSync(opts.serviceAccountKey, "utf-8");
+    keyJson = fs13.readFileSync(opts.serviceAccountKey, "utf-8");
     JSON.parse(keyJson);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -2761,6 +2802,128 @@ async function trafficSync(project, opts) {
   console.log(`  Sample rows:      ${result.sampleRows}`);
   console.log(`  Synced at:        ${result.syncedAt}`);
 }
+function formatSourceLine(source) {
+  const parts = [
+    source.id,
+    source.sourceType,
+    source.status,
+    source.lastSyncedAt ?? "never synced",
+    source.displayName
+  ];
+  return parts.join("  ");
+}
+async function trafficSources(project, opts) {
+  const client = createApiClient();
+  const result = await client.trafficListSources(project);
+  if (opts.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.sources.length === 0) {
+    console.log(`No traffic sources connected for project "${project}".`);
+    console.log("Run: canonry traffic connect cloud-run <project> --gcp-project <id> --service-account-key <path>");
+    return;
+  }
+  console.log(`Traffic sources for "${project}":`);
+  console.log("  ID  TYPE  STATUS  LAST_SYNCED  DISPLAY_NAME");
+  for (const source of result.sources) {
+    console.log(`  ${formatSourceLine(source)}`);
+  }
+}
+async function trafficStatus(project, opts) {
+  const client = createApiClient();
+  const result = await client.trafficStatus(project);
+  const details = result.sources;
+  if (opts.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (details.length === 0) {
+    console.log(`No traffic sources connected for project "${project}".`);
+    console.log("Run: canonry traffic connect cloud-run <project> --gcp-project <id> --service-account-key <path>");
+    return;
+  }
+  for (const d of details) {
+    console.log(`Source ${d.id} (${d.sourceType})`);
+    console.log(`  Display name:    ${d.displayName}`);
+    console.log(`  Status:          ${d.status}`);
+    console.log(`  Last synced:     ${d.lastSyncedAt ?? "never"}`);
+    if (d.lastError) console.log(`  Last error:      ${d.lastError}`);
+    console.log(`  24h crawler:     ${d.totals24h.crawlerHits} hits`);
+    console.log(`  24h AI referral: ${d.totals24h.aiReferralHits} hits`);
+    console.log(`  24h samples:     ${d.totals24h.sampleCount}`);
+    if (d.latestRun) {
+      console.log(`  Latest run:      ${d.latestRun.runId} (${d.latestRun.status})`);
+      console.log(`    Started:       ${d.latestRun.startedAt}`);
+      if (d.latestRun.finishedAt) console.log(`    Finished:      ${d.latestRun.finishedAt}`);
+      if (d.latestRun.error) console.log(`    Error:         ${d.latestRun.error}`);
+    } else {
+      console.log(`  Latest run:      (none)`);
+    }
+    console.log("");
+  }
+}
+function formatEventLine(event) {
+  if (event.kind === TrafficEventKinds.crawler) {
+    return [
+      event.tsHour,
+      "crawler",
+      event.botId,
+      event.verificationStatus,
+      String(event.status),
+      event.pathNormalized,
+      `${event.hits} hits`
+    ].join("  ");
+  }
+  return [
+    event.tsHour,
+    "ai-referral",
+    event.product,
+    event.evidenceType,
+    event.sourceDomain,
+    event.landingPathNormalized,
+    `${event.hits} hits`
+  ].join("  ");
+}
+async function trafficEvents(project, opts) {
+  if (opts.kind && opts.kind !== "all" && opts.kind !== TrafficEventKinds.crawler && opts.kind !== TrafficEventKinds["ai-referral"]) {
+    throw new CliError({
+      code: "TRAFFIC_INVALID_KIND",
+      message: `--kind must be one of: all, ${TrafficEventKinds.crawler}, ${TrafficEventKinds["ai-referral"]}`,
+      displayMessage: `Error: --kind must be "all", "${TrafficEventKinds.crawler}", or "${TrafficEventKinds["ai-referral"]}"`,
+      details: { project, kind: opts.kind }
+    });
+  }
+  const params = {};
+  if (opts.kind && opts.kind !== "all") params.kind = opts.kind;
+  if (opts.source) params.sourceId = opts.source;
+  if (opts.limit !== void 0) params.limit = opts.limit;
+  if (opts.sinceMinutes !== void 0) {
+    const since = new Date(Date.now() - opts.sinceMinutes * 6e4).toISOString();
+    params.since = since;
+  } else if (opts.since) {
+    params.since = opts.since;
+  }
+  if (opts.until) params.until = opts.until;
+  const client = createApiClient();
+  const result = await client.trafficListEvents(project, params);
+  if (opts.format === "json") {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Traffic events for "${project}"  ${result.windowStart}  \u2192  ${result.windowEnd}`);
+  console.log(`  Crawler hits (window):     ${result.totals.crawlerHits}`);
+  console.log(`  AI referral hits (window): ${result.totals.aiReferralHits}`);
+  console.log("");
+  if (result.events.length === 0) {
+    console.log("No events in this window.");
+    return;
+  }
+  console.log("  TS_HOUR  KIND  IDENTITY  EVIDENCE/STATUS  PATH  HITS");
+  for (const event of result.events) {
+    console.log(`  ${formatEventLine(event)}`);
+  }
+}
 
 // src/cli-commands/traffic.ts
 var TRAFFIC_CLI_COMMANDS = [
@@ -2807,7 +2970,7 @@ var TRAFFIC_CLI_COMMANDS = [
   },
   {
     path: ["traffic", "sync"],
-    usage: "canonry traffic sync <project> --source <id> [--since-minutes 60] [--format json]",
+    usage: "canonry traffic sync <project> --source <id> [--since-minutes 43200] [--format json]",
     options: {
       source: stringOption(),
       "since-minutes": stringOption()
@@ -2816,12 +2979,15 @@ var TRAFFIC_CLI_COMMANDS = [
       const project = requireProject(
         input,
         "traffic.sync",
-        "canonry traffic sync <project> --source <id> [--since-minutes 60]"
+        "canonry traffic sync <project> --source <id> [--since-minutes 43200]"
       );
       const source = getString(input.values, "source");
       if (!source) throw new Error("--source <id> is required");
-      const sinceStr = getString(input.values, "since-minutes");
-      const sinceMinutes = sinceStr ? parseInt(sinceStr, 10) : void 0;
+      const sinceMinutes = parseIntegerOption(input, "since-minutes", {
+        command: "traffic.sync",
+        usage: "canonry traffic sync <project> --source <id> [--since-minutes 43200]",
+        message: "--since-minutes must be an integer"
+      });
       await trafficSync(project, {
         source,
         sinceMinutes,
@@ -2829,6 +2995,68 @@ var TRAFFIC_CLI_COMMANDS = [
       });
     }
   },
+  {
+    path: ["traffic", "sources"],
+    usage: "canonry traffic sources <project> [--format json]",
+    run: async (input) => {
+      const project = requireProject(
+        input,
+        "traffic.sources",
+        "canonry traffic sources <project>"
+      );
+      await trafficSources(project, { format: input.format });
+    }
+  },
+  {
+    path: ["traffic", "status"],
+    usage: "canonry traffic status <project> [--format json]",
+    run: async (input) => {
+      const project = requireProject(
+        input,
+        "traffic.status",
+        "canonry traffic status <project>"
+      );
+      await trafficStatus(project, { format: input.format });
+    }
+  },
+  {
+    path: ["traffic", "events"],
+    usage: "canonry traffic events <project> [--kind crawler|ai-referral|all] [--source <id>] [--since-minutes 1440] [--since <iso>] [--until <iso>] [--limit 500] [--format json]",
+    options: {
+      kind: stringOption(),
+      source: stringOption(),
+      "since-minutes": stringOption(),
+      since: stringOption(),
+      until: stringOption(),
+      limit: stringOption()
+    },
+    run: async (input) => {
+      const project = requireProject(
+        input,
+        "traffic.events",
+        "canonry traffic events <project>"
+      );
+      const sinceMinutes = parseIntegerOption(input, "since-minutes", {
+        command: "traffic.events",
+        usage: "canonry traffic events <project> [--since-minutes 1440]",
+        message: "--since-minutes must be an integer"
+      });
+      const limit = parseIntegerOption(input, "limit", {
+        command: "traffic.events",
+        usage: "canonry traffic events <project> [--limit 500]",
+        message: "--limit must be an integer"
+      });
+      await trafficEvents(project, {
+        kind: getString(input.values, "kind"),
+        source: getString(input.values, "source"),
+        sinceMinutes,
+        since: getString(input.values, "since"),
+        until: getString(input.values, "until"),
+        limit,
+        format: input.format
+      });
+    }
+  },
   {
     path: ["traffic"],
     usage: "canonry traffic <subcommand> <project> [args]",
@@ -2836,7 +3064,7 @@ var TRAFFIC_CLI_COMMANDS = [
       unknownSubcommand(input.positionals[0], {
         command: "traffic",
         usage: "canonry traffic <subcommand> <project> [args]",
-        available: ["connect", "sync"]
+        available: ["connect", "sync", "status", "sources", "events"]
       });
     }
   }
@@ -3837,7 +4065,7 @@ var GOOGLE_CLI_COMMANDS = [
 ];
 
 // src/commands/keyword.ts
-import fs from "fs";
+import fs2 from "fs";
 function getClient8() {
   return createApiClient();
 }
@@ -3902,7 +4130,7 @@ async function listKeywords(project, format) {
   }
 }
 async function importKeywords(project, filePath, format) {
-  if (!fs.existsSync(filePath)) {
+  if (!fs2.existsSync(filePath)) {
     throw new CliError({
       code: "KEYWORD_IMPORT_FILE_NOT_FOUND",
       message: `File not found: ${filePath}`,
@@ -3913,7 +4141,7 @@ async function importKeywords(project, filePath, format) {
       }
     });
   }
-  const content = fs.readFileSync(filePath, "utf-8");
+  const content = fs2.readFileSync(filePath, "utf-8");
   const keywords = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   if (keywords.length === 0) {
     if (format === "json") {
@@ -4114,46 +4342,46 @@ var KEYWORD_CLI_COMMANDS = [
 ];
 
 // src/commands/query.ts
-import fs2 from "fs";
+import fs3 from "fs";
 function getClient9() {
   return createApiClient();
 }
-async function addQueries(project, queries, format) {
+async function addQueries(project, queries2, format) {
   const client = getClient9();
-  await client.appendQueries(project, queries);
+  await client.appendQueries(project, queries2);
   if (format === "json") {
     console.log(JSON.stringify({
       project,
-      queries,
-      addedCount: queries.length
+      queries: queries2,
+      addedCount: queries2.length
     }, null, 2));
     return;
   }
-  console.log(`Added ${queries.length} ${queries.length === 1 ? "query" : "queries"} to "${project}".`);
+  console.log(`Added ${queries2.length} ${queries2.length === 1 ? "query" : "queries"} to "${project}".`);
 }
-async function replaceQueries(project, queries, format) {
+async function replaceQueries(project, queries2, format) {
   const client = getClient9();
-  await client.putQueries(project, queries);
+  await client.putQueries(project, queries2);
   if (format === "json") {
     console.log(JSON.stringify({
       project,
-      queries,
-      replacedCount: queries.length
+      queries: queries2,
+      replacedCount: queries2.length
     }, null, 2));
     return;
   }
-  console.log(`Set ${queries.length} ${queries.length === 1 ? "query" : "queries"} for "${project}".`);
+  console.log(`Set ${queries2.length} ${queries2.length === 1 ? "query" : "queries"} for "${project}".`);
 }
-async function removeQueries(project, queries, format) {
+async function removeQueries(project, queries2, format) {
   const client = getClient9();
   const existing = await client.listQueries(project);
   const existingSet = new Set(existing.map((q) => q.query));
-  const removedQueries = queries.filter((q) => existingSet.has(q));
-  await client.deleteQueries(project, queries);
+  const removedQueries = queries2.filter((q) => existingSet.has(q));
+  await client.deleteQueries(project, queries2);
   if (format === "json") {
     console.log(JSON.stringify({
       project,
-      queries,
+      queries: queries2,
       removedQueries,
       removedCount: removedQueries.length
     }, null, 2));
@@ -4179,7 +4407,7 @@ async function listQueries(project, format) {
   }
 }
 async function importQueries(project, filePath, format) {
-  if (!fs2.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     throw new CliError({
       code: "QUERY_IMPORT_FILE_NOT_FOUND",
       message: `File not found: ${filePath}`,
@@ -4190,9 +4418,9 @@ async function importQueries(project, filePath, format) {
       }
     });
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
-  const queries = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
-  if (queries.length === 0) {
+  const content = fs3.readFileSync(filePath, "utf-8");
+  const queries2 = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  if (queries2.length === 0) {
     if (format === "json") {
       console.log(JSON.stringify({
         project,
@@ -4206,17 +4434,17 @@ async function importQueries(project, filePath, format) {
     return;
   }
   const client = getClient9();
-  await client.appendQueries(project, queries);
+  await client.appendQueries(project, queries2);
   if (format === "json") {
     console.log(JSON.stringify({
       project,
       filePath,
-      queries,
-      importedCount: queries.length
+      queries: queries2,
+      importedCount: queries2.length
     }, null, 2));
     return;
   }
-  console.log(`Imported ${queries.length} ${queries.length === 1 ? "query" : "queries"} to "${project}".`);
+  console.log(`Imported ${queries2.length} ${queries2.length === 1 ? "query" : "queries"} to "${project}".`);
 }
 async function generateQueries(project, provider, opts) {
   const client = getClient9();
@@ -4259,8 +4487,8 @@ var QUERY_CLI_COMMANDS = [
     usage: "canonry query add <project> <query...> [--format json]",
     run: async (input) => {
       const project = requireProject(input, "query.add", "canonry query add <project> <query...> [--format json]");
-      const queries = input.positionals.slice(1);
-      if (queries.length === 0) {
+      const queries2 = input.positionals.slice(1);
+      if (queries2.length === 0) {
         throw usageError("Error: project name and at least one query required\nUsage: canonry query add <project> <query...> [--format json]", {
           message: "project name and at least one query required",
           details: {
@@ -4269,7 +4497,7 @@ var QUERY_CLI_COMMANDS = [
           }
         });
       }
-      await addQueries(project, queries, input.format);
+      await addQueries(project, queries2, input.format);
     }
   },
   {
@@ -4277,8 +4505,8 @@ var QUERY_CLI_COMMANDS = [
     usage: "canonry query replace <project> <query...> [--format json]",
     run: async (input) => {
       const project = requireProject(input, "query.replace", "canonry query replace <project> <query...> [--format json]");
-      const queries = input.positionals.slice(1);
-      if (queries.length === 0) {
+      const queries2 = input.positionals.slice(1);
+      if (queries2.length === 0) {
         throw usageError("Error: project name and at least one query required\nUsage: canonry query replace <project> <query...> [--format json]", {
           message: "project name and at least one query required",
           details: {
@@ -4287,7 +4515,7 @@ var QUERY_CLI_COMMANDS = [
           }
         });
       }
-      await replaceQueries(project, queries, input.format);
+      await replaceQueries(project, queries2, input.format);
     }
   },
   {
@@ -4295,8 +4523,8 @@ var QUERY_CLI_COMMANDS = [
     usage: "canonry query remove <project> <query...> [--format json]",
     run: async (input) => {
       const project = requireProject(input, "query.remove", "canonry query remove <project> <query...> [--format json]");
-      const queries = input.positionals.slice(1);
-      if (queries.length === 0) {
+      const queries2 = input.positionals.slice(1);
+      if (queries2.length === 0) {
         throw usageError("Error: project name and at least one query required\nUsage: canonry query remove <project> <query...> [--format json]", {
           message: "project name and at least one query required",
           details: {
@@ -4305,7 +4533,7 @@ var QUERY_CLI_COMMANDS = [
           }
         });
       }
-      await removeQueries(project, queries, input.format);
+      await removeQueries(project, queries2, input.format);
     }
   },
   {
@@ -4313,8 +4541,8 @@ var QUERY_CLI_COMMANDS = [
     usage: "canonry query delete <project> <query...> [--format json]",
     run: async (input) => {
       const project = requireProject(input, "query.delete", "canonry query delete <project> <query...> [--format json]");
-      const queries = input.positionals.slice(1);
-      if (queries.length === 0) {
+      const queries2 = input.positionals.slice(1);
+      if (queries2.length === 0) {
         throw usageError("Error: project name and at least one query required\nUsage: canonry query delete <project> <query...> [--format json]", {
           message: "project name and at least one query required",
           details: {
@@ -4323,7 +4551,7 @@ var QUERY_CLI_COMMANDS = [
           }
         });
       }
-      await removeQueries(project, queries, input.format);
+      await removeQueries(project, queries2, input.format);
     }
   },
   {
@@ -4391,7 +4619,7 @@ var QUERY_CLI_COMMANDS = [
 ];
 
 // src/commands/mcp.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import path2 from "path";
 import { createRequire } from "module";
 
@@ -4497,8 +4725,8 @@ function renderClientSnippet(client, serverName, entry) {
   return renderJsonSnippet(serverName, entry, client.format);
 }
 function readJsonConfig(configPath) {
-  if (!fs3.existsSync(configPath)) return {};
-  const raw = fs3.readFileSync(configPath, "utf-8").trim();
+  if (!fs4.existsSync(configPath)) return {};
+  const raw = fs4.readFileSync(configPath, "utf-8").trim();
   if (!raw) return {};
   try {
     const parsed = JSON.parse(raw);
@@ -4516,14 +4744,14 @@ function readJsonConfig(configPath) {
   }
 }
 function writeJsonConfig(configPath, value) {
-  fs3.mkdirSync(path2.dirname(configPath), { recursive: true });
-  fs3.writeFileSync(configPath, `${JSON.stringify(value, null, 2)}
+  fs4.mkdirSync(path2.dirname(configPath), { recursive: true });
+  fs4.writeFileSync(configPath, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
 }
 function backupConfigIfPresent(configPath) {
-  if (!fs3.existsSync(configPath)) return void 0;
+  if (!fs4.existsSync(configPath)) return void 0;
   const backupPath = `${configPath}.canonry.bak`;
-  fs3.copyFileSync(configPath, backupPath);
+  fs4.copyFileSync(configPath, backupPath);
   return backupPath;
 }
 function findClientOrThrow(id) {
@@ -4870,13 +5098,13 @@ var NOTIFY_CLI_COMMANDS = [
 ];
 
 // src/commands/apply.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import { parseAllDocuments } from "yaml";
 async function applyConfigFile(filePath) {
-  if (!fs4.existsSync(filePath)) {
+  if (!fs5.existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const content = fs4.readFileSync(filePath, "utf-8");
+  const content = fs5.readFileSync(filePath, "utf-8");
   const docs = parseAllDocuments(content);
   const client = createApiClient();
   const errors = [];
@@ -5620,7 +5848,7 @@ var PROJECT_CLI_COMMANDS = [
 ];
 
 // src/commands/report.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path3 from "path";
 function defaultOutputPath(project, audience) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -5637,10 +5865,10 @@ async function runReportCommand(project, opts = {}) {
   const html = renderReportHtml(report, { audience });
   const targetPath = opts.output ? path3.resolve(opts.output) : defaultOutputPath(project, audience);
   const dir = path3.dirname(targetPath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
-  fs5.writeFileSync(targetPath, html, "utf-8");
+  fs6.writeFileSync(targetPath, html, "utf-8");
   console.log(`Report written to ${targetPath}`);
 }
 
@@ -6381,7 +6609,7 @@ Usage: canonry settings provider ${name} --api-key <key> [--model <model>] [--ma
 ];
 
 // src/commands/skills.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path4 from "path";
 import { fileURLToPath } from "url";
 var BUNDLED_SKILL_NAMES = ["canonry-setup", "aero"];
@@ -6393,7 +6621,7 @@ function resolveBundledSkillsRoot(pkgDir) {
     path4.join(here, "../../../../skills")
   ];
   for (const candidate of candidates) {
-    if (BUNDLED_SKILL_NAMES.every((name) => fs6.existsSync(path4.join(candidate, name, "SKILL.md")))) {
+    if (BUNDLED_SKILL_NAMES.every((name) => fs7.existsSync(path4.join(candidate, name, "SKILL.md")))) {
       return candidate;
     }
   }
@@ -6416,13 +6644,13 @@ function getBundledSkills(pkgDir) {
   return BUNDLED_SKILL_NAMES.map((name) => {
     const skillDir = path4.join(root, name);
     const skillFile = path4.join(skillDir, "SKILL.md");
-    const content = fs6.readFileSync(skillFile, "utf-8");
+    const content = fs7.readFileSync(skillFile, "utf-8");
     return { name, description: parseDescription(content), bundledPath: skillDir };
   });
 }
 function walkRelative(dir, prefix = "") {
   const out = [];
-  for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs7.readdirSync(dir, { withFileTypes: true })) {
     const rel = prefix ? path4.join(prefix, entry.name) : entry.name;
     const full = path4.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -6434,28 +6662,28 @@ function walkRelative(dir, prefix = "") {
   return out.sort();
 }
 function compareDirContent(srcDir, destDir) {
-  if (!fs6.existsSync(destDir)) return "missing";
-  if (!fs6.statSync(destDir).isDirectory()) return "different";
+  if (!fs7.existsSync(destDir)) return "missing";
+  if (!fs7.statSync(destDir).isDirectory()) return "different";
   const srcFiles = walkRelative(srcDir);
   const destFiles = walkRelative(destDir);
   if (srcFiles.length !== destFiles.length) return "different";
   for (let i = 0; i < srcFiles.length; i++) {
     if (srcFiles[i] !== destFiles[i]) return "different";
-    const srcBytes = fs6.readFileSync(path4.join(srcDir, srcFiles[i]));
-    const destBytes = fs6.readFileSync(path4.join(destDir, destFiles[i]));
+    const srcBytes = fs7.readFileSync(path4.join(srcDir, srcFiles[i]));
+    const destBytes = fs7.readFileSync(path4.join(destDir, destFiles[i]));
     if (!srcBytes.equals(destBytes)) return "different";
   }
   return "match";
 }
 function copyDirRecursive(src, dest) {
-  fs6.mkdirSync(dest, { recursive: true });
-  for (const entry of fs6.readdirSync(src, { withFileTypes: true })) {
+  fs7.mkdirSync(dest, { recursive: true });
+  for (const entry of fs7.readdirSync(src, { withFileTypes: true })) {
     const srcPath = path4.join(src, entry.name);
     const destPath = path4.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else if (entry.isFile()) {
-      fs6.copyFileSync(srcPath, destPath);
+      fs7.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -6480,7 +6708,7 @@ function installClaudeSkill(skill, targetDir, force) {
     });
   }
   if (compare === "different") {
-    fs6.rmSync(targetPath, { recursive: true, force: true });
+    fs7.rmSync(targetPath, { recursive: true, force: true });
   }
   copyDirRecursive(skill.bundledPath, targetPath);
   return {
@@ -6495,15 +6723,15 @@ function installCodexSymlink(skill, targetDir, force) {
   const codexPath = path4.join(targetDir, ".codex", "skills", skill.name);
   const claudePath = path4.join(targetDir, ".claude", "skills", skill.name);
   const linkTarget = path4.relative(path4.dirname(codexPath), claudePath);
-  fs6.mkdirSync(path4.dirname(codexPath), { recursive: true });
+  fs7.mkdirSync(path4.dirname(codexPath), { recursive: true });
   let stat;
   try {
-    stat = fs6.lstatSync(codexPath);
+    stat = fs7.lstatSync(codexPath);
   } catch {
     stat = void 0;
   }
   if (stat?.isSymbolicLink()) {
-    const existing = fs6.readlinkSync(codexPath);
+    const existing = fs7.readlinkSync(codexPath);
     if (existing === linkTarget) {
       return {
         skill: skill.name,
@@ -6521,8 +6749,8 @@ function installCodexSymlink(skill, targetDir, force) {
         exitCode: 1
       });
     }
-    fs6.unlinkSync(codexPath);
-    fs6.symlinkSync(linkTarget, codexPath);
+    fs7.unlinkSync(codexPath);
+    fs7.symlinkSync(linkTarget, codexPath);
     return {
       skill: skill.name,
       client: CodingAgents.codex,
@@ -6540,9 +6768,9 @@ function installCodexSymlink(skill, targetDir, force) {
         exitCode: 1
       });
     }
-    fs6.rmSync(codexPath, { recursive: true, force: true });
+    fs7.rmSync(codexPath, { recursive: true, force: true });
   }
-  fs6.symlinkSync(linkTarget, codexPath);
+  fs7.symlinkSync(linkTarget, codexPath);
   return {
     skill: skill.name,
     client: CodingAgents.codex,
@@ -6574,7 +6802,7 @@ async function installSkills(opts = {}) {
     });
   }
   const skillsToInstall = allSkills.filter((s) => requestedNames.includes(s.name));
-  fs6.mkdirSync(targetDir, { recursive: true });
+  fs7.mkdirSync(targetDir, { recursive: true });
   const results = [];
   for (const skill of skillsToInstall) {
     results.push(installClaudeSkill(skill, targetDir, force));
@@ -6675,11 +6903,11 @@ var SKILLS_CLI_COMMANDS = [
 ];
 
 // src/commands/snapshot.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path6 from "path";
 
 // src/snapshot-pdf.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path5 from "path";
 import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
 var PAGE_WIDTH = 612;
@@ -6890,8 +7118,8 @@ async function writeSnapshotPdf(report, outputPath) {
   renderQueries(pdf, report);
   const bytes = await doc.save();
   const resolvedPath = path5.resolve(outputPath);
-  fs7.mkdirSync(path5.dirname(resolvedPath), { recursive: true });
-  fs7.writeFileSync(resolvedPath, bytes);
+  fs8.mkdirSync(path5.dirname(resolvedPath), { recursive: true });
+  fs8.writeFileSync(resolvedPath, bytes);
   return resolvedPath;
 }
 function renderCover(pdf, report) {
@@ -7050,8 +7278,8 @@ PDF saved: ${savedPdfPath}`);
 }
 function writeSnapshotMarkdown(report, outputPath) {
   const resolvedPath = path6.resolve(outputPath);
-  fs8.mkdirSync(path6.dirname(resolvedPath), { recursive: true });
-  fs8.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
+  fs9.mkdirSync(path6.dirname(resolvedPath), { recursive: true });
+  fs9.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
   return resolvedPath;
 }
 function formatSnapshotMarkdown(report) {
@@ -7993,7 +8221,7 @@ async function bootstrapCommand(_opts) {
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import fs9 from "fs";
+import fs10 from "fs";
 import path8 from "path";
 function getPidPath() {
   return path8.join(getConfigDir(), "canonry.pid");
@@ -8023,8 +8251,8 @@ async function waitForReady(host, port, maxMs = 1e4) {
 async function startDaemon(opts) {
   const pidPath = getPidPath();
   const format = opts.format ?? "text";
-  if (fs9.existsSync(pidPath)) {
-    const existingPid = parseInt(fs9.readFileSync(pidPath, "utf-8").trim(), 10);
+  if (fs10.existsSync(pidPath)) {
+    const existingPid = parseInt(fs10.readFileSync(pidPath, "utf-8").trim(), 10);
     if (!isNaN(existingPid) && isProcessAlive(existingPid)) {
       throw new CliError({
         code: "DAEMON_ALREADY_RUNNING",
@@ -8035,7 +8263,7 @@ async function startDaemon(opts) {
         }
       });
     }
-    fs9.unlinkSync(pidPath);
+    fs10.unlinkSync(pidPath);
   }
   const cliPath = path8.resolve(new URL(import.meta.url).pathname);
   const inSourceMode = new URL(import.meta.url).pathname.endsWith(".ts");
@@ -8056,10 +8284,10 @@ async function startDaemon(opts) {
     });
   }
   const configDir = getConfigDir();
-  if (!fs9.existsSync(configDir)) {
-    fs9.mkdirSync(configDir, { recursive: true });
+  if (!fs10.existsSync(configDir)) {
+    fs10.mkdirSync(configDir, { recursive: true });
   }
-  fs9.writeFileSync(pidPath, String(child.pid), "utf-8");
+  fs10.writeFileSync(pidPath, String(child.pid), "utf-8");
   const port = opts.port ?? "4100";
   const host = opts.host ?? "127.0.0.1";
   if (format !== "json") {
@@ -8068,7 +8296,7 @@ async function startDaemon(opts) {
   const ready = await waitForReady(host, port);
   if (!ready) {
     try {
-      fs9.unlinkSync(pidPath);
+      fs10.unlinkSync(pidPath);
     } catch {
     }
     throw new CliError({
@@ -8100,7 +8328,7 @@ async function startDaemon(opts) {
 }
 function stopDaemon(format = "text") {
   const pidPath = getPidPath();
-  if (!fs9.existsSync(pidPath)) {
+  if (!fs10.existsSync(pidPath)) {
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: false,
@@ -8111,7 +8339,7 @@ function stopDaemon(format = "text") {
     console.log("Canonry is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs9.readFileSync(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(fs10.readFileSync(pidPath, "utf-8").trim(), 10);
   if (isNaN(pid)) {
     if (format === "json") {
       console.log(JSON.stringify({
@@ -8122,7 +8350,7 @@ function stopDaemon(format = "text") {
     } else {
       console.error("Invalid PID file. Removing it.");
     }
-    fs9.unlinkSync(pidPath);
+    fs10.unlinkSync(pidPath);
     return;
   }
   if (!isProcessAlive(pid)) {
@@ -8136,12 +8364,12 @@ function stopDaemon(format = "text") {
     } else {
       console.log(`Canonry is not running (stale PID: ${pid}). Cleaning up.`);
     }
-    fs9.unlinkSync(pidPath);
+    fs10.unlinkSync(pidPath);
     return;
   }
   try {
     process.kill(pid, "SIGTERM");
-    fs9.unlinkSync(pidPath);
+    fs10.unlinkSync(pidPath);
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: true,
@@ -8165,7 +8393,7 @@ function stopDaemon(format = "text") {
 
 // src/commands/init.ts
 import crypto2 from "crypto";
-import fs10 from "fs";
+import fs11 from "fs";
 import readline from "readline";
 import path9 from "path";
 function prompt(question) {
@@ -8189,7 +8417,7 @@ var PROJECT_MARKERS = [".git", "canonry.yaml", "canonry.yml", "package.json"];
 function cwdLooksLikeProject(dir) {
   const home = process.env.HOME ?? "";
   if (home && path9.resolve(dir) === path9.resolve(home)) return false;
-  return PROJECT_MARKERS.some((marker) => fs10.existsSync(path9.join(dir, marker)));
+  return PROJECT_MARKERS.some((marker) => fs11.existsSync(path9.join(dir, marker)));
 }
 var DEFAULT_AGENT_MODELS = {
   anthropic: "anthropic/claude-sonnet-4-6",
@@ -8219,8 +8447,8 @@ async function initCommand(opts) {
     return void 0;
   }
   const configDir = getConfigDir();
-  if (!fs10.existsSync(configDir)) {
-    fs10.mkdirSync(configDir, { recursive: true });
+  if (!fs11.existsSync(configDir)) {
+    fs11.mkdirSync(configDir, { recursive: true });
   }
   const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
@@ -8530,6 +8758,7 @@ Received ${signal}, stopping server...`);
 Canonry server running at ${url}`);
       console.log("Press Ctrl+C to stop.\n");
     }
+    setTelemetrySource("cli-server");
     const providerNames = Object.keys(config.providers ?? {}).filter(
       (k) => config.providers?.[k]?.apiKey || config.providers?.[k]?.baseUrl
     );
@@ -8815,7 +9044,7 @@ var SYSTEM_CLI_COMMANDS = [
 ];
 
 // src/cli-commands/wordpress.ts
-import fs11 from "fs";
+import fs12 from "fs";
 
 // src/commands/wordpress.ts
 function getClient20() {
@@ -9051,12 +9280,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs12 = await import("fs/promises");
+  const fs13 = await import("fs/promises");
   const path10 = await import("path");
   const filePath = path10.resolve(opts.from);
   let raw;
   try {
-    raw = await fs12.readFile(filePath, "utf8");
+    raw = await fs13.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -9153,13 +9382,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs12 = await import("fs/promises");
+  const fs13 = await import("fs/promises");
   const path10 = await import("path");
   const yaml = await import("yaml").catch(() => null);
   const filePath = path10.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs12.readFile(filePath, "utf8");
+    raw = await fs13.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -9264,13 +9493,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs12 = await import("fs/promises");
+    const fs13 = await import("fs/promises");
     const path10 = await import("path");
     const yaml = await import("yaml").catch(() => null);
     const filePath = path10.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs12.readFile(filePath, "utf8");
+      raw = await fs13.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -9419,7 +9648,7 @@ function resolveContent(input, command, usage, options) {
   }
   if (contentFile) {
     try {
-      return fs11.readFileSync(contentFile, "utf-8");
+      return fs12.readFileSync(contentFile, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw usageError(`Error: could not read --content-file "${contentFile}": ${message}`, {
@@ -10410,6 +10639,7 @@ Integrations:
   google                Google Search Console / Analytics
   bing                  Bing Webmaster Tools
   wordpress             WordPress REST API
+  traffic               Server-side traffic ingestion (Cloud Run)
 
 Automation:
   schedule              Manage scheduled runs
@@ -10451,7 +10681,7 @@ async function runCli(args = process.argv.slice(2)) {
     showFirstRunNotice();
     getOrCreateAnonymousId();
   }
-  const SUBCOMMAND_COMMANDS = /* @__PURE__ */ new Set(["backfill", "project", "query", "keyword", "competitor", "schedule", "notify", "settings", "telemetry", "google", "bing", "wordpress", "cdp"]);
+  const SUBCOMMAND_COMMANDS = /* @__PURE__ */ new Set(["backfill", "project", "query", "keyword", "competitor", "schedule", "notify", "settings", "telemetry", "google", "bing", "wordpress", "cdp", "traffic"]);
   const MIXED_SUBCOMMANDS = {
     insights: /* @__PURE__ */ new Set(["dismiss"]),
     run: /* @__PURE__ */ new Set(["show", "cancel"])
@@ -10465,7 +10695,12 @@ async function runCli(args = process.argv.slice(2)) {
     resolvedCommand = command;
   }
   if (!isHelpRequest && command !== "telemetry") {
-    trackEvent("cli.command", { command: resolvedCommand });
+    detectAndTrackUpgrade();
+    const setupState = buildSetupState();
+    trackEvent("cli.command", {
+      command: resolvedCommand,
+      ...setupState ? { setup_state: setupState } : {}
+    });
   }
   try {
     if (await dispatchRegisteredCommand(args, format, REGISTERED_CLI_COMMANDS)) {