npm - @ainyc/canonry - Versions diffs - 4.19.1 → 4.21.1 - Mend

@ainyc/canonry 4.19.1 → 4.21.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/assets/assets/{index-CVqSCXSn.js → index-CChQIKw5.js} +110 -110
package/assets/index.html +1 -1
package/dist/{chunk-OHPZXTFC.js → chunk-3UGJUNQX.js} +301 -6
package/dist/{chunk-SBZTDECX.js → chunk-EY63PENL.js} +15 -1
package/dist/{chunk-BN2VQDZ2.js → chunk-GVQYROIK.js} +1 -1
package/dist/{chunk-P3SFTXHG.js → chunk-VFKGHXVJ.js} +24 -1
package/dist/cli.js +104 -6
package/dist/index.js +4 -4
package/dist/{intelligence-service-6CX5HH27.js → intelligence-service-5COCQKXG.js} +2 -2
package/dist/mcp.js +2 -2
package/package.json +8 -8

package/assets/index.html CHANGED Viewed

@@ -12,7 +12,7 @@
     <link rel="icon" type="image/png" sizes="32x32" href="./favicon-32.png" />
     <link rel="apple-touch-icon" href="./apple-touch-icon.png" />
     <title>Canonry</title>
-    <script type="module" crossorigin src="./assets/index-CVqSCXSn.js"></script>
+    <script type="module" crossorigin src="./assets/index-CChQIKw5.js"></script>
     <link rel="stylesheet" crossorigin href="./assets/index-QBgWzl2L.css">
   </head>
   <body>

package/dist/{chunk-OHPZXTFC.js → chunk-3UGJUNQX.js} RENAMED Viewed

@@ -5,7 +5,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-P3SFTXHG.js";
+} from "./chunk-VFKGHXVJ.js";
 import {
   DEFAULT_RUN_HISTORY_LIMIT,
   IntelligenceService,
@@ -66,7 +66,7 @@ import {
   schedules,
   trafficSources,
   usageCounters
-} from "./chunk-BN2VQDZ2.js";
+} from "./chunk-GVQYROIK.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -159,7 +159,7 @@ import {
   visibilityStateFromAnswerMentioned,
   windowCutoff,
   wordpressEnvSchema
-} from "./chunk-SBZTDECX.js";
+} from "./chunk-EY63PENL.js";
 // src/telemetry.ts
 import crypto from "crypto";
@@ -10037,6 +10037,35 @@ var routeCatalog = [
       502: { description: "Upstream Cloud Run pull or auth-token resolution failed." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/traffic/sources/{id}/backfill",
+    summary: "Reclassify historical Cloud Run logs for a traffic source",
+    description: 'Async one-shot backfill: pulls the last `days` of request logs (clamped server-side to the upstream retention ceiling \u2014 30d for Cloud Logging `_Default`), classifies them with the current rules, and replaces the hourly rollup buckets + sample slice in the window inside one transaction. Returns immediately with `{ runId, status: "running" }`; poll `GET /runs/{id}` for completion. lastSyncedAt only advances forward, so a backfill never undoes incremental sync progress that ran ahead of it.',
+    tags: ["traffic"],
+    parameters: [
+      nameParameter,
+      { name: "id", in: "path", required: true, description: "Traffic source ID.", schema: stringSchema }
+    ],
+    requestBody: {
+      required: false,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              days: { ...integerSchema, description: "Lookback window in days (default 30, capped at the upstream retention ceiling)." }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Backfill submitted; poll the returned runId for completion." },
+      400: { description: "Invalid backfill request or missing credentials." },
+      404: { description: "Project or traffic source not found." }
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/traffic/sources",
@@ -13008,7 +13037,7 @@ async function bingRoutes(app, opts) {
       impressions: s.Impressions,
       clicks: s.Clicks,
       ctr: s.Impressions > 0 ? s.Clicks / s.Impressions : 0,
-      averagePosition: s.AverageClickPosition ?? s.AverageImpressionPosition ?? 0
+      averagePosition: s.AvgClickPosition > 0 ? s.AvgClickPosition : s.AvgImpressionPosition > 0 ? s.AvgImpressionPosition : 0
     }));
   });
 }
@@ -16584,11 +16613,12 @@ async function listCloudRunTrafficEvents(accessToken, options) {
   let rawEntryCount = 0;
   let skippedEntryCount = 0;
   const events = [];
+  const orderBy = options.orderBy ?? (options.firstSync ? "timestamp desc" : "timestamp asc");
   for (let page = 0; page < maxPages; page += 1) {
     const requestBody = {
       resourceNames: [`projects/${options.gcpProjectId}`],
       filter,
-      orderBy: options.orderBy ?? "timestamp asc",
+      orderBy,
       pageSize
     };
     if (pageToken) {
@@ -16763,6 +16793,14 @@ function utmSourceFromQuery(queryString) {
   const source = params.get("utm_source");
   return source ? normalizeHost(source) : null;
 }
+function utmSourceFromUrl(value) {
+  if (!value) return null;
+  try {
+    return utmSourceFromQuery(new URL(value).search.replace(/^\?/, ""));
+  } catch {
+    return null;
+  }
+}
 function classifyCrawler(event) {
   const userAgent = event.userAgent?.trim();
   if (!userAgent) return null;
@@ -16805,6 +16843,18 @@ function classifyAiReferral(event) {
       };
     }
   }
+  const refererUtmSource = utmSourceFromUrl(event.referer);
+  if (refererUtmSource) {
+    const rule = DEFAULT_AI_REFERRER_RULES.find((candidate) => hostMatches(refererUtmSource, candidate.domain));
+    if (rule) {
+      return {
+        operator: rule.operator,
+        product: rule.product,
+        sourceDomain: refererUtmSource,
+        evidenceType: "referer-utm"
+      };
+    }
+  }
   return null;
 }
@@ -16965,6 +17015,10 @@ var DEFAULT_PAGE_SIZE2 = 1e3;
 var DEFAULT_MAX_PAGES2 = 5;
 var DEFAULT_SAMPLE_LIMIT2 = 100;
 var MAX_TRACKED_EVENT_IDS = 1e3;
+var DEFAULT_BACKFILL_DAYS = 30;
+var MAX_BACKFILL_DAYS = 30;
+var BACKFILL_MAX_PAGES = 1e3;
+var BACKFILL_SAMPLE_LIMIT = 500;
 function parseSourceConfig(row) {
   return parseJsonColumn(row.configJson, {});
 }
@@ -16995,6 +17049,173 @@ async function defaultResolveAccessToken(record) {
     "OAuth-mode Cloud Run sync is not yet supported in v1. Provide a service-account key file."
   );
 }
+async function runBackfillTask(options) {
+  const {
+    app,
+    runId,
+    project,
+    sourceRow,
+    gcpProjectId,
+    serviceName,
+    location,
+    credential,
+    windowStart,
+    windowEnd,
+    pullEvents,
+    resolveAccessToken: resolveAccessToken2
+  } = options;
+  const markFailed = (msg) => {
+    const failedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      app.db.transaction((tx) => {
+        tx.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: failedAt }).where(eq23(runs.id, runId)).run();
+        tx.update(trafficSources).set({ status: TrafficSourceStatuses.error, lastError: msg, updatedAt: failedAt }).where(eq23(trafficSources.id, sourceRow.id)).run();
+      });
+    } catch {
+    }
+  };
+  let accessToken;
+  try {
+    accessToken = await resolveAccessToken2(credential);
+  } catch (e) {
+    markFailed(`Failed to resolve Cloud Run access token: ${e instanceof Error ? e.message : String(e)}`);
+    return;
+  }
+  const allEvents = [];
+  try {
+    const page = await pullEvents(accessToken, {
+      gcpProjectId,
+      serviceName,
+      location,
+      startTime: windowStart.toISOString(),
+      endTime: windowEnd.toISOString(),
+      pageSize: DEFAULT_PAGE_SIZE2,
+      maxPages: BACKFILL_MAX_PAGES,
+      // Backfill is intentionally `firstSync: false`. We don't want desc
+      // ordering — the in-memory rollup builder handles any order, and the
+      // ring-buffer reseed at the end takes the most-recent IDs from the
+      // dedupedEvents anyway.
+      firstSync: false,
+      orderBy: "timestamp asc"
+    });
+    allEvents.push(...page.events);
+  } catch (e) {
+    markFailed(`Cloud Run pull failed: ${e instanceof Error ? e.message : String(e)}`);
+    return;
+  }
+  if (allEvents.length === 0) {
+    const finishedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: finishedAt2 }).where(eq23(runs.id, runId)).run();
+    } catch {
+    }
+    return;
+  }
+  const report = buildTrafficProbeReport(allEvents, { sampleLimit: BACKFILL_SAMPLE_LIMIT });
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const windowStartIso = windowStart.toISOString();
+  const windowEndIso = windowEnd.toISOString();
+  const newSorted = allEvents.slice().sort((a, b) => a.observedAt < b.observedAt ? 1 : a.observedAt > b.observedAt ? -1 : 0).map((e) => e.eventId);
+  const newRingBuffer = newSorted.slice(0, MAX_TRACKED_EVENT_IDS);
+  const currentLastSyncedMs = sourceRow.lastSyncedAt ? new Date(sourceRow.lastSyncedAt).getTime() : Number.NEGATIVE_INFINITY;
+  const nextLastSyncedAt = Math.max(currentLastSyncedMs, windowEnd.getTime()) === windowEnd.getTime() ? finishedAt : sourceRow.lastSyncedAt;
+  try {
+    app.db.transaction((tx) => {
+      tx.delete(crawlerEventsHourly).where(
+        and14(
+          eq23(crawlerEventsHourly.sourceId, sourceRow.id),
+          gte2(crawlerEventsHourly.tsHour, windowStartIso),
+          lte2(crawlerEventsHourly.tsHour, windowEndIso)
+        )
+      ).run();
+      tx.delete(aiReferralEventsHourly).where(
+        and14(
+          eq23(aiReferralEventsHourly.sourceId, sourceRow.id),
+          gte2(aiReferralEventsHourly.tsHour, windowStartIso),
+          lte2(aiReferralEventsHourly.tsHour, windowEndIso)
+        )
+      ).run();
+      tx.delete(rawEventSamples).where(
+        and14(
+          eq23(rawEventSamples.sourceId, sourceRow.id),
+          gte2(rawEventSamples.ts, windowStartIso),
+          lte2(rawEventSamples.ts, windowEndIso)
+        )
+      ).run();
+      for (const bucket of report.crawlerEventsHourly) {
+        tx.insert(crawlerEventsHourly).values({
+          projectId: project.id,
+          sourceId: sourceRow.id,
+          tsHour: bucket.tsHour,
+          botId: bucket.botId,
+          operator: bucket.operator,
+          verificationStatus: bucket.verificationStatus,
+          pathNormalized: bucket.pathNormalized,
+          status: bucket.status ?? 0,
+          hits: bucket.hits,
+          sampledUserAgent: bucket.sampledUserAgent,
+          createdAt: finishedAt,
+          updatedAt: finishedAt
+        }).run();
+      }
+      for (const bucket of report.aiReferralEventsHourly) {
+        tx.insert(aiReferralEventsHourly).values({
+          projectId: project.id,
+          sourceId: sourceRow.id,
+          tsHour: bucket.tsHour,
+          product: bucket.product,
+          operator: bucket.operator,
+          sourceDomain: bucket.sourceDomain,
+          evidenceType: bucket.evidenceType,
+          landingPathNormalized: bucket.landingPathNormalized,
+          status: bucket.status ?? 0,
+          sessionsOrHits: bucket.hits,
+          usersEstimated: null,
+          createdAt: finishedAt,
+          updatedAt: finishedAt
+        }).run();
+      }
+      for (const sample of report.samples) {
+        const eventType = sample.crawler ? "crawler" : sample.aiReferral ? "ai_referral" : "unknown";
+        const refererHost = (() => {
+          if (!sample.referer) return null;
+          try {
+            return new URL(sample.referer).hostname;
+          } catch {
+            return null;
+          }
+        })();
+        tx.insert(rawEventSamples).values({
+          id: crypto20.randomUUID(),
+          projectId: project.id,
+          sourceId: sourceRow.id,
+          ts: sample.observedAt,
+          eventType,
+          ipHash: null,
+          userAgent: sample.userAgent,
+          pathNormalized: sample.pathNormalized,
+          status: sample.status,
+          refererHost,
+          classifierDetailsJson: JSON.stringify({
+            crawler: sample.crawler,
+            aiReferral: sample.aiReferral
+          }),
+          createdAt: finishedAt
+        }).run();
+      }
+      tx.update(trafficSources).set({
+        status: TrafficSourceStatuses.connected,
+        lastSyncedAt: nextLastSyncedAt,
+        lastError: null,
+        lastEventIds: JSON.stringify(newRingBuffer),
+        updatedAt: finishedAt
+      }).where(eq23(trafficSources.id, sourceRow.id)).run();
+      tx.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq23(runs.id, runId)).run();
+    });
+  } catch (e) {
+    markFailed(`Backfill rollup write failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
 async function trafficRoutes(app, opts) {
   const pullEvents = opts.pullCloudRunEvents ?? listCloudRunTrafficEvents;
   const resolveAccessToken2 = opts.resolveCloudRunAccessToken ?? defaultResolveAccessToken;
@@ -17158,6 +17379,7 @@ async function trafficRoutes(app, opts) {
       markFailed(msg, "PROVIDER_AUTH");
       throw providerError(`Failed to resolve Cloud Run access token: ${msg}`);
     }
+    const isFirstSync = !sourceRow.lastSyncedAt;
     let allEvents = [];
     try {
       const page = await pullEvents(accessToken, {
@@ -17167,7 +17389,8 @@ async function trafficRoutes(app, opts) {
         startTime: windowStart.toISOString(),
         endTime: windowEnd.toISOString(),
         pageSize,
-        maxPages
+        maxPages,
+        firstSync: isFirstSync
       });
       allEvents = page.events;
     } catch (e) {
@@ -17334,6 +17557,78 @@ async function trafficRoutes(app, opts) {
     };
     return response;
   });
+  app.post("/projects/:name/traffic/sources/:id/backfill", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const sourceRow = app.db.select().from(trafficSources).where(eq23(trafficSources.id, request.params.id)).get();
+    if (!sourceRow || sourceRow.projectId !== project.id) {
+      throw notFound("Traffic source", request.params.id);
+    }
+    if (sourceRow.sourceType !== TrafficSourceTypes["cloud-run"]) {
+      throw validationError(
+        `Backfill for source type "${sourceRow.sourceType}" is not implemented yet \u2014 only cloud-run is supported in v1.`
+      );
+    }
+    const credentialStore = opts.cloudRunCredentialStore;
+    if (!credentialStore) {
+      throw validationError("Cloud Run credential storage is not configured for this deployment");
+    }
+    const credential = credentialStore.getConnection(project.name);
+    if (!credential) {
+      throw validationError(
+        `No Cloud Run credential found for project "${project.name}". Run "canonry traffic connect cloud-run" first.`
+      );
+    }
+    const requestedDays = request.body?.days ?? DEFAULT_BACKFILL_DAYS;
+    if (!Number.isInteger(requestedDays) || requestedDays <= 0) {
+      throw validationError('"days" must be a positive integer');
+    }
+    const appliedDays = Math.min(requestedDays, MAX_BACKFILL_DAYS);
+    const config = parseSourceConfig(sourceRow);
+    const gcpProjectId = config.gcpProjectId ?? credential.gcpProjectId;
+    const serviceName = config.serviceName ?? credential.serviceName ?? void 0;
+    const location = config.location ?? credential.location ?? void 0;
+    const windowEnd = /* @__PURE__ */ new Date();
+    const windowStart = new Date(windowEnd.getTime() - appliedDays * 864e5);
+    windowStart.setUTCMinutes(0, 0, 0);
+    const startedAt = windowEnd.toISOString();
+    const runId = crypto20.randomUUID();
+    app.db.insert(runs).values({
+      id: runId,
+      projectId: project.id,
+      kind: RunKinds["traffic-sync"],
+      status: RunStatuses.running,
+      trigger: RunTriggers.backfill,
+      sourceId: sourceRow.id,
+      startedAt,
+      createdAt: startedAt
+    }).run();
+    void runBackfillTask({
+      app,
+      runId,
+      project,
+      sourceRow,
+      gcpProjectId,
+      serviceName,
+      location,
+      credential,
+      windowStart,
+      windowEnd,
+      appliedDays,
+      pullEvents,
+      resolveAccessToken: resolveAccessToken2
+    }).catch(() => {
+    });
+    const response = {
+      sourceId: sourceRow.id,
+      runId,
+      status: RunStatuses.running,
+      windowStart: windowStart.toISOString(),
+      windowEnd: windowEnd.toISOString(),
+      daysRequested: requestedDays,
+      daysApplied: appliedDays
+    };
+    return response;
+  });
   function buildSourceDetail(projectId, row, since) {
     const crawlerTotals = app.db.select({ total: sql8`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
       and14(

package/dist/{chunk-SBZTDECX.js → chunk-EY63PENL.js} RENAMED Viewed

@@ -91,7 +91,7 @@ var runKindSchema = z2.enum([
   "traffic-sync"
 ]);
 var RunKinds = runKindSchema.enum;
-var runTriggerSchema = z2.enum(["manual", "scheduled", "config-apply"]);
+var runTriggerSchema = z2.enum(["manual", "scheduled", "config-apply", "backfill"]);
 var RunTriggers = runTriggerSchema.enum;
 var citationStateSchema = z2.enum(["cited", "not-cited"]);
 var CitationStates = citationStateSchema.enum;
@@ -2263,6 +2263,20 @@ var trafficSyncResponseSchema = z20.object({
   windowStart: z20.string(),
   windowEnd: z20.string()
 });
+var trafficBackfillRequestSchema = z20.object({
+  /** Lookback window in days. Capped server-side at the upstream log retention ceiling (Cloud Logging _Default = 30d). Default: 30. */
+  days: z20.number().int().positive().optional()
+});
+var trafficBackfillResponseSchema = z20.object({
+  sourceId: z20.string(),
+  runId: z20.string(),
+  status: runStatusSchema,
+  windowStart: z20.string(),
+  windowEnd: z20.string(),
+  /** Days actually used after server-side clamping (≤ requested). */
+  daysRequested: z20.number().int().positive(),
+  daysApplied: z20.number().int().positive()
+});
 var trafficSourceTotalsSchema = z20.object({
   crawlerHits: z20.number().int().nonnegative(),
   aiReferralHits: z20.number().int().nonnegative(),

package/dist/{chunk-BN2VQDZ2.js → chunk-GVQYROIK.js} RENAMED Viewed

@@ -8,7 +8,7 @@ import {
   categoryLabel,
   determineAnswerMentioned,
   normalizeProjectDomain
-} from "./chunk-SBZTDECX.js";
+} from "./chunk-EY63PENL.js";
 // src/intelligence-service.ts
 import { eq, desc, asc, and, or, inArray } from "drizzle-orm";

package/dist/{chunk-P3SFTXHG.js → chunk-VFKGHXVJ.js} RENAMED Viewed

@@ -15,7 +15,7 @@ import {
   scheduleUpsertRequestSchema,
   trafficConnectCloudRunRequestSchema,
   trafficEventKindSchema
-} from "./chunk-SBZTDECX.js";
+} from "./chunk-EY63PENL.js";
 // src/config.ts
 import fs from "fs";
@@ -773,6 +773,13 @@ var ApiClient = class {
       body ?? {}
     );
   }
+  async trafficBackfill(project, sourceId, body) {
+    return this.request(
+      "POST",
+      `/projects/${encodeURIComponent(project)}/traffic/sources/${encodeURIComponent(sourceId)}/backfill`,
+      body ?? {}
+    );
+  }
   async trafficListSources(project) {
     return this.request(
       "GET",
@@ -1190,6 +1197,11 @@ var trafficSyncInputSchema = z2.object({
   sourceId: z2.string().min(1).describe("Traffic source ID returned by canonry_traffic_connect_cloud_run or canonry_traffic_sources_list."),
   sinceMinutes: z2.number().int().positive().max(7 * 24 * 60).optional().describe("Lookback window in minutes. Defaults to the source's configured window (60 min) when omitted; clamped forward to lastSyncedAt to avoid double-counting.")
 });
+var trafficBackfillInputSchema = z2.object({
+  project: projectNameSchema,
+  sourceId: z2.string().min(1).describe("Traffic source ID returned by canonry_traffic_sources_list."),
+  days: z2.number().int().positive().max(30).optional().describe("Lookback window in days. Default 30, capped server-side at the upstream log retention ceiling (Cloud Logging _Default = 30d).")
+});
 var trafficEventsInputSchema = z2.object({
   project: projectNameSchema,
   since: z2.string().optional().describe("ISO 8601 lower bound. Defaults to 24h ago when omitted."),
@@ -1788,6 +1800,17 @@ var canonryMcpTools = [
     openApiOperations: ["POST /api/v1/projects/{name}/traffic/sources/{id}/sync"],
     handler: (client, input) => client.trafficSync(input.project, input.sourceId, input.sinceMinutes !== void 0 ? { sinceMinutes: input.sinceMinutes } : void 0)
   }),
+  defineTool({
+    name: "canonry_traffic_backfill",
+    title: "Backfill Cloud Run traffic source",
+    description: 'Async one-shot reclassification of historical Cloud Run logs. Pulls the last `days` of request logs (capped at the 30d Cloud Logging retention ceiling), classifies them with current rules, and replaces the hourly rollup buckets + sample slice in the window. Returns immediately with `{ runId, status: "running" }`; poll canonry_run_get for completion. lastSyncedAt only advances forward \u2014 a backfill never undoes incremental sync progress that ran ahead of it.',
+    access: "write",
+    tier: "traffic",
+    inputSchema: trafficBackfillInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true, openWorldHint: true }),
+    openApiOperations: ["POST /api/v1/projects/{name}/traffic/sources/{id}/backfill"],
+    handler: (client, input) => client.trafficBackfill(input.project, input.sourceId, input.days !== void 0 ? { days: input.days } : void 0)
+  }),
   defineTool({
     name: "canonry_project_upsert",
     title: "Create or replace project",

package/dist/cli.js CHANGED Viewed

@@ -20,7 +20,7 @@ import {
   setTelemetrySource,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-OHPZXTFC.js";
+} from "./chunk-3UGJUNQX.js";
 import {
   CliError,
   EXIT_SYSTEM_ERROR,
@@ -36,7 +36,7 @@ import {
   saveConfig,
   saveConfigPatch,
   usageError
-} from "./chunk-P3SFTXHG.js";
+} from "./chunk-VFKGHXVJ.js";
 import {
   apiKeys,
   competitors,
@@ -49,7 +49,7 @@ import {
   queries,
   querySnapshots,
   runs
-} from "./chunk-BN2VQDZ2.js";
+} from "./chunk-GVQYROIK.js";
 import {
   CcReleaseSyncStatuses,
   CheckScopes,
@@ -69,7 +69,7 @@ import {
   providerQuotaPolicySchema,
   resolveProviderInput,
   skillsClientSchema
-} from "./chunk-SBZTDECX.js";
+} from "./chunk-EY63PENL.js";
 // src/cli.ts
 import { pathToFileURL } from "url";
@@ -621,7 +621,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService } = await import("./intelligence-service-6CX5HH27.js");
+  const { IntelligenceService } = await import("./intelligence-service-5COCQKXG.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -2775,6 +2775,75 @@ async function trafficConnectCloudRun(project, opts) {
   console.log("");
   console.log(`Next: canonry traffic sync ${project} --source ${result.id}`);
 }
+async function trafficBackfill(project, opts) {
+  if (!opts.source) {
+    throw new CliError({
+      code: "TRAFFIC_SOURCE_REQUIRED",
+      message: "--source <id> is required",
+      displayMessage: "Error: --source <id> is required (run `canonry traffic sources` to list connected sources)",
+      details: { project }
+    });
+  }
+  const client = getClient5();
+  const submitted = await client.trafficBackfill(project, opts.source, {
+    days: opts.days
+  });
+  if (!opts.wait) {
+    if (opts.format === "json") {
+      console.log(JSON.stringify(submitted, null, 2));
+      return;
+    }
+    console.log(`Backfill submitted for "${project}" (source ${opts.source}).`);
+    console.log(`  Run ID:        ${submitted.runId}`);
+    console.log(`  Window:        ${submitted.windowStart}  \u2192  ${submitted.windowEnd}`);
+    console.log(`  Days applied:  ${submitted.daysApplied} (requested ${submitted.daysRequested})`);
+    console.log(`  Status:        ${submitted.status}`);
+    console.log("");
+    console.log(`Poll: canonry runs get ${submitted.runId}`);
+    return;
+  }
+  const intervalMs = opts.pollIntervalMs ?? 1500;
+  const deadlineMs = Date.now() + 5 * 6e4;
+  let final = null;
+  while (Date.now() < deadlineMs) {
+    const run = await client.getRun(submitted.runId);
+    if (run.status !== RunStatuses.running && run.status !== RunStatuses.queued) {
+      final = run;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  if (!final) {
+    throw new CliError({
+      code: "TRAFFIC_BACKFILL_TIMEOUT",
+      message: `Backfill did not complete within 5 minutes (run ${submitted.runId} still running)`,
+      displayMessage: `Error: backfill run ${submitted.runId} did not finish within 5 minutes \u2014 check status with "canonry runs get ${submitted.runId}"`,
+      details: { project, runId: submitted.runId }
+    });
+  }
+  if (opts.format === "json") {
+    console.log(JSON.stringify({ ...submitted, finalStatus: final.status, finalRun: final }, null, 2));
+    return;
+  }
+  if (final.status === RunStatuses.completed) {
+    console.log(`Backfill complete for "${project}" (source ${opts.source}).`);
+    console.log(`  Run ID:        ${final.id}`);
+    console.log(`  Window:        ${submitted.windowStart}  \u2192  ${submitted.windowEnd}`);
+    console.log(`  Days applied:  ${submitted.daysApplied}`);
+    console.log(`  Started:       ${final.startedAt ?? "unknown"}`);
+    console.log(`  Finished:      ${final.finishedAt ?? "unknown"}`);
+    console.log("");
+    console.log(`Inspect rebuilt rollups: canonry traffic events ${project} --source ${opts.source} --since-minutes ${submitted.daysApplied * 24 * 60}`);
+    return;
+  }
+  const errorMessage = final.error?.message ?? null;
+  throw new CliError({
+    code: "TRAFFIC_BACKFILL_FAILED",
+    message: errorMessage ?? "backfill run did not complete successfully",
+    displayMessage: `Error: backfill run ${final.id} ${final.status}${errorMessage ? ` \u2014 ${errorMessage}` : ""}`,
+    details: { project, runId: final.id, status: final.status }
+  });
+}
 async function trafficSync(project, opts) {
   if (!opts.source) {
     throw new CliError({
@@ -2995,6 +3064,35 @@ var TRAFFIC_CLI_COMMANDS = [
       });
     }
   },
+  {
+    path: ["traffic", "backfill"],
+    usage: "canonry traffic backfill <project> --source <id> [--days 30] [--wait] [--format json]",
+    options: {
+      source: stringOption(),
+      days: stringOption(),
+      wait: { type: "boolean" }
+    },
+    run: async (input) => {
+      const project = requireProject(
+        input,
+        "traffic.backfill",
+        "canonry traffic backfill <project> --source <id> [--days 30] [--wait]"
+      );
+      const source = getString(input.values, "source");
+      if (!source) throw new Error("--source <id> is required");
+      const days = parseIntegerOption(input, "days", {
+        command: "traffic.backfill",
+        usage: "canonry traffic backfill <project> --source <id> [--days 30] [--wait]",
+        message: "--days must be a positive integer"
+      });
+      await trafficBackfill(project, {
+        source,
+        days,
+        wait: getBoolean(input.values, "wait"),
+        format: input.format
+      });
+    }
+  },
   {
     path: ["traffic", "sources"],
     usage: "canonry traffic sources <project> [--format json]",
@@ -3064,7 +3162,7 @@ var TRAFFIC_CLI_COMMANDS = [
       unknownSubcommand(input.positionals[0], {
         command: "traffic",
         usage: "canonry traffic <subcommand> <project> [args]",
-        available: ["connect", "sync", "status", "sources", "events"]
+        available: ["connect", "sync", "backfill", "status", "sources", "events"]
       });
     }
   }

package/dist/index.js CHANGED Viewed

@@ -1,11 +1,11 @@
 import {
   createServer
-} from "./chunk-OHPZXTFC.js";
+} from "./chunk-3UGJUNQX.js";
 import {
   loadConfig
-} from "./chunk-P3SFTXHG.js";
-import "./chunk-BN2VQDZ2.js";
-import "./chunk-SBZTDECX.js";
+} from "./chunk-VFKGHXVJ.js";
+import "./chunk-GVQYROIK.js";
+import "./chunk-EY63PENL.js";
 export {
   createServer,
   loadConfig