@agent-native/core 0.121.2 → 0.122.1

package/corpus/templates/clips/actions/get-recording-insights.ts

@@ -3,8 +3,10 @@
  *
  * Owner-only — uses assertAccess at editor level (owners always satisfy).
  *
- * Returns: views, uniqueViewers, completionRate, dropOff (100 buckets),
- * ctaConversionRate.
+ * Returns: views (total counted human view sessions, so a returning viewer
+ * counts again), agentViews (outside agents reading the clip's agent APIs),
+ * uniqueViewers (distinct people behind those views), completionRate,
+ * dropOff (100 buckets), ctaConversionRate.
  *
  * Usage:
  *   pnpm action get-recording-insights --recordingId=<id>
@@ -12,11 +14,19 @@
 
 import { defineAction } from "@agent-native/core";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { count, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { clampCompletionPct } from "../shared/view-analytics.js";
+import {
+  countRecordingAgentViews,
+  listRecordingAgentViewers,
+} from "../server/lib/agent-views.js";
+import {
+  clampCompletionPct,
+  displayViewerName,
+  isCountedViewerRow,
+} from "../shared/view-analytics.js";
 
 export default defineAction({
   description:
@@ -39,11 +49,31 @@ export default defineAction({
       .from(schema.recordingEvents)
       .where(eq(schema.recordingEvents.recordingId, args.recordingId));
 
-    const views = viewerRows.filter((v) => v.countedView).length;
+    const [[viewLogRow], agentViews, agentViewers] = await Promise.all([
+      db
+        .select({ value: count() })
+        .from(schema.recordingViews)
+        .where(eq(schema.recordingViews.recordingId, args.recordingId)),
+      countRecordingAgentViews(args.recordingId),
+      listRecordingAgentViewers(args.recordingId),
+    ]);
+
+    // Same definition as `countedViewCondition`, applied to rows already in
+    // memory so this action keeps its single viewer-row read. One row per
+    // person, so this is the distinct-viewer count, not the view total.
+    const countedViewers = viewerRows.filter(isCountedViewerRow).length;
     const uniqueViewers = new Set(
-      viewerRows.map((v) => v.viewerEmail ?? `anon:${v.id}`),
+      viewerRows
+        .filter(isCountedViewerRow)
+        .map((v) => v.viewerEmail ?? `anon:${v.id}`),
     ).size;
 
+    // Mirrors `countRecordingViews`: `recording_views` only exists from
+    // migration v46, so clips recorded before it have zero log rows. Floor the
+    // total at the counted-viewer count so those clips keep reporting a real
+    // number instead of 0, and so total can never read below uniqueViewers.
+    const views = Math.max(Number(viewLogRow?.value ?? 0), countedViewers);
+
     const completionRate =
       viewerRows.length === 0
         ? 0
@@ -75,8 +105,12 @@ export default defineAction({
     }
 
     const ctaClicks = events.filter((e) => e.kind === "cta-click").length;
+    // CTA conversion is per person, so the denominator is counted viewers — not
+    // `views`, which counts repeat sessions from the same viewer.
     const ctaConversionRate =
-      views === 0 ? 0 : Math.min(100, (ctaClicks / views) * 100);
+      countedViewers === 0
+        ? 0
+        : Math.min(100, (ctaClicks / countedViewers) * 100);
 
     // Top viewers by total watch ms
     const topViewers = viewerRows
@@ -85,13 +119,15 @@ export default defineAction({
       .slice(0, 20)
       .map((v) => ({
         viewerEmail: v.viewerEmail,
-        viewerName: v.viewerName,
+        viewerName: displayViewerName(v.viewerName),
         totalWatchMs: v.totalWatchMs ?? 0,
         completedPct: clampCompletionPct(v.completedPct),
       }));
 
     return {
       views,
+      agentViews,
+      agentViewers,
       uniqueViewers,
       completionRate,
       ctaConversionRate,

package/corpus/templates/clips/actions/get-recording-player-data.ts

@@ -7,6 +7,7 @@
  *   - reactions
  *   - chapters (parsed from recording.chaptersJson)
  *   - CTAs
+ *   - counted-view total
  *
  * This is the read endpoint the player/:id and share/:id routes use.
  * Access is gated by assertAccess at viewer level — for public-visibility
@@ -20,23 +21,24 @@
 import { defineAction, embedApp } from "@agent-native/core";
 import { readAppState } from "@agent-native/core/application-state";
 import { buildDeepLink } from "@agent-native/core/server";
-import {
-  getRequestOrgId,
-  getRequestUserEmail,
-} from "@agent-native/core/server/request-context";
 import { resolveAccess, ForbiddenError } from "@agent-native/core/sharing";
-import { and, asc, eq, or, sql } from "drizzle-orm";
+import { asc, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { isAgentRecordingCaller } from "../server/lib/agent-recording-access.js";
+import { countRecordingAgentViews } from "../server/lib/agent-views.js";
 import { isMediaVerificationPending } from "../server/lib/media-verification-state.js";
 import { resolvePlayerVideoUrl } from "../server/lib/player-video-url.js";
 import {
   canOpenDirectRecordingPage,
   isRecordingExpired,
 } from "../server/lib/recording-page-access.js";
-import { parseSpaceIds } from "../server/lib/recordings.js";
+import { hasExplicitRecordingShare } from "../server/lib/recording-share-grant.js";
+import {
+  countRecordingViews,
+  parseSpaceIds,
+} from "../server/lib/recordings.js";
 import { parseBrowserDiagnosticsRow } from "../shared/browser-diagnostics.js";
 import {
   CLIPS_BUILDER_CREDITS_STATE_KEY,
@@ -93,7 +95,7 @@ function recordingDeepLink(recordingId: string): string {
 
 export default defineAction({
   description:
-    "Fetch everything the player page needs for a recording: metadata, transcript, comments, reactions, chapters, CTAs, and the caller's effective role. Agent calls receive a bounded transcript payload; browser player calls receive the full transcript.",
+    "Fetch everything the player page needs for a recording: metadata, transcript, comments, reactions, chapters, CTAs, the counted-view total, and the caller's effective role. Agent calls receive a bounded transcript payload; browser player calls receive the full transcript.",
   schema: z.object({
     recordingId: z.string().describe("Recording ID"),
   }),
@@ -121,55 +123,13 @@ export default defineAction({
       throw new ForbiddenError("Recording has expired");
     }
 
-    let hasExplicitShare = access.role === "owner";
-    if (
-      rec.visibility === "public" &&
-      access.role !== "owner" &&
-      !rec.password &&
-      isAgentRecordingCaller(ctx?.caller)
-    ) {
-      hasExplicitShare = true;
-    }
-    if (
-      rec.visibility === "public" &&
-      access.role !== "owner" &&
-      !hasExplicitShare
-    ) {
-      const userEmail = getRequestUserEmail()?.trim().toLowerCase();
-      const orgId = getRequestOrgId();
-      const principals = [];
-      if (userEmail) {
-        principals.push(
-          and(
-            eq(schema.recordingShares.principalType, "user"),
-            sql`lower(${schema.recordingShares.principalId}) = ${userEmail}`,
-          ),
-        );
-      }
-      if (orgId) {
-        principals.push(
-          and(
-            eq(schema.recordingShares.principalType, "org"),
-            eq(schema.recordingShares.principalId, orgId),
-          ),
-        );
-      }
-      if (principals.length > 0) {
-        const [share] = await db
-          .select({ id: schema.recordingShares.id })
-          .from(schema.recordingShares)
-          .where(
-            and(
-              eq(schema.recordingShares.resourceId, args.recordingId),
-              or(...principals),
-            ),
-          )
-          .limit(1);
-        hasExplicitShare = Boolean(share);
-      } else {
-        hasExplicitShare = false;
-      }
-    }
+    const hasExplicitShare = await hasExplicitRecordingShare({
+      recordingId: args.recordingId,
+      role: access.role,
+      visibility: rec.visibility,
+      hasPassword: Boolean(rec.password),
+      isAgentCaller: isAgentRecordingCaller(ctx?.caller),
+    });
 
     if (
       !canOpenDirectRecordingPage({
@@ -193,20 +153,27 @@ export default defineAction({
       access.role === "owner" ||
       access.role === "admin" ||
       access.role === "editor";
-    const [cleanupStateRaw, builderCreditsRaw, verificationPending] =
-      await Promise.all([
-        readAppState(`transcript-cleanup-${args.recordingId}`).catch(
-          () => null,
-        ),
-        canEditRecording
-          ? readAppState(CLIPS_BUILDER_CREDITS_STATE_KEY).catch(() => null)
-          : Promise.resolve(null),
-        isMediaVerificationPending({
-          ownerEmail: rec.ownerEmail,
-          recordingId: args.recordingId,
-          recordingStatus: rec.status,
-        }),
-      ]);
+    // This action is on a 1-3s poll from the player, so every read here shares
+    // one Promise.all instead of adding serial round-trips.
+    const [
+      cleanupStateRaw,
+      builderCreditsRaw,
+      verificationPending,
+      viewCount,
+      agentViewCount,
+    ] = await Promise.all([
+      readAppState(`transcript-cleanup-${args.recordingId}`).catch(() => null),
+      canEditRecording
+        ? readAppState(CLIPS_BUILDER_CREDITS_STATE_KEY).catch(() => null)
+        : Promise.resolve(null),
+      isMediaVerificationPending({
+        ownerEmail: rec.ownerEmail,
+        recordingId: args.recordingId,
+        recordingStatus: rec.status,
+      }),
+      countRecordingViews(args.recordingId).catch(() => 0),
+      countRecordingAgentViews(args.recordingId).catch(() => 0),
+    ]);
     const cleanupState =
       cleanupStateRaw && typeof cleanupStateRaw === "object"
         ? (cleanupStateRaw as Record<string, unknown>)
@@ -338,6 +305,8 @@ export default defineAction({
 
     return {
       role: access.role,
+      viewCount,
+      agentViewCount,
       recording: {
         id: rec.id,
         organizationId: rec.organizationId,

package/corpus/templates/clips/actions/import-loom-recording.ts

@@ -1,14 +1,13 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
-import { uploadFile } from "@agent-native/core/file-upload";
 import { buildDeepLink } from "@agent-native/core/server";
 import { extractLoomVideoId, normalizeLoomShareUrl } from "@shared/loom.js";
 import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { queueBuilderMediaCompression } from "../server/lib/builder-media-compression.js";
+import { dispatchPostFinalizeJob } from "../server/lib/post-finalize-dispatch.js";
 import {
   getCurrentOwnerEmail,
   getOrganizationDefaultVisibility,
@@ -19,11 +18,7 @@ import {
   stringifySpaceIds,
 } from "../server/lib/recordings.js";
 import { hasRequestVideoStorage } from "../server/lib/video-storage.js";
-import {
-  fetchLoomTranscript,
-  loomTranscriptUnavailableMessage,
-} from "./lib/loom-transcript.js";
-import { downloadLoomVideo } from "./lib/loom-video.js";
+import { failLoomImport } from "./lib/loom-import-job.js";
 
 const LoomOembedSchema = z
   .object({
@@ -132,7 +127,7 @@ async function fetchLoomOembed(shareUrl: string) {
 
 export default defineAction({
   description:
-    "Import a public Loom share URL into Clips as a playable recording. Downloads Loom's public MP4, reuploads it to the configured Clips storage provider, and imports Loom's public transcript when available. If storage is not connected, creates a waiting recording that can be retried after storage setup.",
+    "Import a public Loom share URL into Clips as a playable recording. Creates the recording immediately and downloads Loom's public MP4, reuploads it to the configured Clips storage provider, and imports Loom's public transcript in the background (Loom's CDN plus a reupload can take longer than a single request should block on). If storage is not connected, creates a waiting recording that can be retried after storage setup.",
   schema: ImportLoomRecordingSchema,
   run: async (args) => {
     const shareUrl = normalizeLoomShareUrl(args.url);
@@ -163,15 +158,17 @@ export default defineAction({
       const existingSourceUrl = normalizeLoomShareUrl(
         existingRecording.sourceWindowTitle ?? "",
       );
-      const isWaitingStorageRetry =
-        existingRecording.status === "uploading" &&
+      const isRetryableLoomImport =
         !existingRecording.videoUrl &&
-        existingRecording.failureReason ===
-          LOOM_STORAGE_SETUP_REQUIRED_REASON &&
-        existingSourceUrl === shareUrl;
-      if (!isWaitingStorageRetry) {
+        existingSourceUrl === shareUrl &&
+        (existingRecording.status === "processing" ||
+          existingRecording.status === "failed" ||
+          (existingRecording.status === "uploading" &&
+            existingRecording.failureReason ===
+              LOOM_STORAGE_SETUP_REQUIRED_REASON));
+      if (!isRetryableLoomImport) {
         throw new Error(
-          "Only a waiting-storage Loom import can be retried in place.",
+          "Only an incomplete Loom import can be retried in place.",
         );
       }
     }
@@ -241,6 +238,8 @@ export default defineAction({
             status: "uploading",
             videoUrl: null,
             failureReason: LOOM_STORAGE_SETUP_REQUIRED_REASON,
+            loomImportClaimId: null,
+            loomImportClaimedAt: null,
           })
           .where(eq(schema.recordings.id, id));
       } else {
@@ -293,123 +292,79 @@ export default defineAction({
       );
     }
 
-    const media = await downloadLoomVideo({ loomId, shareUrl });
-    const upload = await uploadFile({
-      data: media.bytes,
-      filename: `${id}.mp4`,
-      mimeType: media.mimeType,
-      ownerEmail,
-      stableUrl: true,
-      recordAsset: false,
-    });
-
-    const recordingValues = buildRecordingValues(media.sizeBytes);
-    if (upload === null) {
-      return await saveWaitingForStorage(media.sizeBytes);
-    }
-
-    if (!upload?.url) {
-      throw new Error(
-        "File upload returned no URL. Check your storage provider configuration.",
-      );
-    }
-
-    const videoUrl = upload.url;
+    // Storage is connected: create the row now and hand the slow Loom
+    // download + reupload + transcript off to a durable background job.
+    // Loom's CDN plus a reupload can outlast the platform's request timeout;
+    // doing it inline previously crashed the function mid-download instead of
+    // returning a clean error (see post-finalize-worker.post.ts's "loom-import"
+    // kind / runLoomImportJob).
+    const recordingValues = buildRecordingValues(
+      existingRecording?.videoSizeBytes ?? 0,
+    );
     if (existingRecording) {
       await db
         .update(schema.recordings)
         .set({
           ...recordingValues,
-          videoUrl,
-          status: "ready",
+          status: "processing",
+          videoUrl: null,
           failureReason: null,
+          loomImportClaimId: null,
+          loomImportClaimedAt: null,
         })
         .where(eq(schema.recordings.id, id));
     } else {
       await db.insert(schema.recordings).values({
         id,
         ...recordingValues,
-        videoUrl,
-        status: "ready",
+        videoUrl: null,
+        status: "processing",
         failureReason: null,
         ownerEmail,
         createdAt: now,
       });
     }
 
-    void queueBuilderMediaCompression({
+    await writeAppState(`recording-upload-${id}`, {
       recordingId: id,
-      ownerEmail,
-      videoUrl,
-      mimeType: media.mimeType,
-      providerId: upload.provider,
-      assetDbId: upload.id,
-      sourceSizeBytes: media.sizeBytes,
-    }).catch((err) => {
-      console.warn("[clips] Loom media compression queue failed", {
-        recordingId: id,
-        error: err instanceof Error ? err.message : String(err),
-      });
+      status: "processing",
+      progress: 100,
+      provider: "loom",
+      sourceUrl: shareUrl,
+      durationMs,
+      width,
+      height,
+      hasAudio: true,
+      hasCamera: false,
+      updatedAt: now,
     });
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    await writeAppState("navigate", { view: "recording", recordingId: id });
 
-    let transcript: Awaited<ReturnType<typeof fetchLoomTranscript>> = null;
     try {
-      transcript = await fetchLoomTranscript({ shareUrl, durationMs });
-    } catch (err) {
-      console.warn(
-        `[clips] Loom transcript import skipped for ${loomId}:`,
-        (err as Error)?.message ?? String(err),
-      );
-    }
-
-    const transcriptValues = {
-      ownerEmail,
-      language: transcript?.language ?? "en",
-      segmentsJson: transcript ? JSON.stringify(transcript.segments) : "[]",
-      fullText: transcript?.fullText ?? "",
-      status: transcript ? ("ready" as const) : ("failed" as const),
-      failureReason: transcript ? null : loomTranscriptUnavailableMessage(),
-      updatedAt: now,
-    };
-    const [existingTranscript] = await db
-      .select({ recordingId: schema.recordingTranscripts.recordingId })
-      .from(schema.recordingTranscripts)
-      .where(eq(schema.recordingTranscripts.recordingId, id));
-    if (existingTranscript) {
-      await db
-        .update(schema.recordingTranscripts)
-        .set(transcriptValues)
-        .where(eq(schema.recordingTranscripts.recordingId, id));
-    } else {
-      await db.insert(schema.recordingTranscripts).values({
+      await dispatchPostFinalizeJob({
         recordingId: id,
-        ...transcriptValues,
-        createdAt: now,
+        kind: "loom-import",
+        requireAccepted: true,
       });
+    } catch (err) {
+      const failureReason = `Could not start the Loom import: ${
+        err instanceof Error ? err.message : String(err)
+      }`;
+      await failLoomImport(id, failureReason);
+      throw new Error(failureReason);
     }
 
-    await writeAppState("refresh-signal", { ts: Date.now() });
-    await writeAppState("navigate", { view: "recording", recordingId: id });
-
     return {
       recordingId: id,
       title,
-      status: "ready" as const,
+      status: "processing" as const,
       provider: "loom" as const,
       sourceUrl: shareUrl,
-      videoUrl,
-      embedUrl: videoUrl,
       thumbnailUrl: oembed.thumbnail_url ?? null,
       durationMs,
-      transcriptStatus: transcript
-        ? ("ready" as const)
-        : ("unavailable" as const),
       importMode: "reuploaded" as const,
-      storageProvider: upload.provider,
-      videoSizeBytes: media.sizeBytes,
-      note: transcript
-        ? "Imported as a Clips-hosted MP4 with Loom's public transcript."
-        : "Imported as a Clips-hosted MP4. Loom did not expose an importable transcript; use request-transcript to transcribe the uploaded media.",
+      note: "Downloading and importing this Loom recording in the background.",
     };
   },
   link: ({ result }) => {