@agent-native/core 0.121.2 → 0.122.1

package/corpus/templates/clips/actions/lib/loom-import-job.ts

@@ -0,0 +1,260 @@
+import { writeAppState } from "@agent-native/core/application-state";
+import { uploadFile } from "@agent-native/core/file-upload";
+import { and, eq } from "drizzle-orm";
+
+import { getDb, schema } from "../../server/db/index.js";
+import { queueBuilderMediaCompression } from "../../server/lib/builder-media-compression.js";
+import {
+  extractLoomVideoId,
+  normalizeLoomShareUrl,
+} from "../../shared/loom.js";
+import {
+  fetchLoomTranscript,
+  loomTranscriptUnavailableMessage,
+} from "./loom-transcript.js";
+import { downloadLoomVideo } from "./loom-video.js";
+
+export type LoomImportJobResult = {
+  status: "ready" | "failed";
+  failureReason?: string;
+};
+
+export async function failLoomImport(
+  recordingId: string,
+  failureReason: string,
+  claimId?: string,
+): Promise<LoomImportJobResult> {
+  const now = new Date().toISOString();
+  const [updated] = await getDb()
+    .update(schema.recordings)
+    .set({
+      status: "failed",
+      failureReason,
+      loomImportClaimId: null,
+      loomImportClaimedAt: null,
+      updatedAt: now,
+    })
+    .where(
+      claimId
+        ? and(
+            eq(schema.recordings.id, recordingId),
+            eq(schema.recordings.loomImportClaimId, claimId),
+          )
+        : eq(schema.recordings.id, recordingId),
+    )
+    .returning({ id: schema.recordings.id });
+  if (!updated) return { status: "failed", failureReason };
+
+  try {
+    await writeAppState(`recording-upload-${recordingId}`, {
+      recordingId,
+      status: "failed",
+      failureReason,
+      updatedAt: now,
+    });
+    await writeAppState("refresh-signal", { ts: Date.now() });
+  } catch (err) {
+    console.warn("[clips] Loom failure state update failed", {
+      recordingId,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  }
+  return { status: "failed", failureReason };
+}
+
+/**
+ * Downloads a Loom video and re-uploads it to Clips storage, off the request
+ * that created the "processing" row. Loom's CDN plus a reupload can outlast a
+ * synchronous serverless function's execution ceiling; running it here keeps
+ * import-loom-recording's own request fast regardless of Loom video length.
+ */
+export async function runLoomImportJob({
+  recordingId,
+  ownerEmail,
+  claimId,
+}: {
+  recordingId: string;
+  ownerEmail: string;
+  claimId: string;
+}): Promise<LoomImportJobResult> {
+  const db = getDb();
+  const [recording] = await db
+    .select({
+      id: schema.recordings.id,
+      durationMs: schema.recordings.durationMs,
+      sourceWindowTitle: schema.recordings.sourceWindowTitle,
+      loomImportClaimId: schema.recordings.loomImportClaimId,
+    })
+    .from(schema.recordings)
+    .where(eq(schema.recordings.id, recordingId));
+
+  const shareUrl = normalizeLoomShareUrl(recording?.sourceWindowTitle ?? "");
+  const loomId = shareUrl ? extractLoomVideoId(shareUrl) : null;
+  if (
+    !recording ||
+    recording.loomImportClaimId !== claimId ||
+    !shareUrl ||
+    !loomId
+  ) {
+    return failLoomImport(
+      recordingId,
+      "This Loom recording is missing its source URL.",
+      claimId,
+    );
+  }
+
+  let media: Awaited<ReturnType<typeof downloadLoomVideo>>;
+  try {
+    media = await downloadLoomVideo({ loomId, shareUrl });
+  } catch (err) {
+    return failLoomImport(
+      recordingId,
+      err instanceof Error ? err.message : String(err),
+      claimId,
+    );
+  }
+
+  try {
+    const upload = await uploadFile({
+      data: media.bytes,
+      filename: `${recordingId}.mp4`,
+      mimeType: media.mimeType,
+      ownerEmail,
+      stableUrl: true,
+      recordAsset: false,
+    });
+    if (!upload?.url) {
+      return failLoomImport(
+        recordingId,
+        "File upload returned no URL. Check your storage provider configuration.",
+        claimId,
+      );
+    }
+
+    const now = new Date().toISOString();
+    const [mediaReady] = await db
+      .update(schema.recordings)
+      .set({
+        videoUrl: upload.url,
+        videoSizeBytes: media.sizeBytes,
+        status: "ready",
+        failureReason: null,
+        updatedAt: now,
+      })
+      .where(
+        and(
+          eq(schema.recordings.id, recordingId),
+          eq(schema.recordings.loomImportClaimId, claimId),
+        ),
+      )
+      .returning({ id: schema.recordings.id });
+    if (!mediaReady) {
+      return {
+        status: "failed",
+        failureReason: "The Loom import lease was lost before media was saved.",
+      };
+    }
+
+    void queueBuilderMediaCompression({
+      recordingId,
+      ownerEmail,
+      videoUrl: upload.url,
+      mimeType: media.mimeType,
+      providerId: upload.provider,
+      assetDbId: upload.id,
+      sourceSizeBytes: media.sizeBytes,
+    }).catch((err) => {
+      console.warn("[clips] Loom media compression queue failed", {
+        recordingId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    });
+
+    try {
+      let transcript: Awaited<ReturnType<typeof fetchLoomTranscript>> = null;
+      try {
+        transcript = await fetchLoomTranscript({
+          shareUrl,
+          durationMs: recording.durationMs,
+        });
+      } catch (err) {
+        console.warn(
+          `[clips] Loom transcript import skipped for ${loomId}:`,
+          err instanceof Error ? err.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, recordingId));
+      if (existingTranscript) {
+        await db
+          .update(schema.recordingTranscripts)
+          .set(transcriptValues)
+          .where(eq(schema.recordingTranscripts.recordingId, recordingId));
+      } else {
+        await db.insert(schema.recordingTranscripts).values({
+          recordingId,
+          ...transcriptValues,
+          createdAt: now,
+        });
+      }
+    } catch (err) {
+      console.warn("[clips] Loom transcript persistence skipped", {
+        recordingId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+
+    try {
+      await writeAppState(`recording-upload-${recordingId}`, {
+        recordingId,
+        status: "ready",
+        progress: 100,
+        videoUrl: upload.url,
+        updatedAt: now,
+      });
+      await writeAppState("refresh-signal", { ts: Date.now() });
+    } catch (err) {
+      console.warn("[clips] Loom ready state update skipped", {
+        recordingId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+
+    try {
+      await db
+        .update(schema.recordings)
+        .set({ loomImportClaimId: null, loomImportClaimedAt: null })
+        .where(
+          and(
+            eq(schema.recordings.id, recordingId),
+            eq(schema.recordings.loomImportClaimId, claimId),
+          ),
+        );
+    } catch (err) {
+      console.warn("[clips] Loom import lease release failed", {
+        recordingId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+
+    return { status: "ready" };
+  } catch (err) {
+    return failLoomImport(
+      recordingId,
+      err instanceof Error ? err.message : String(err),
+      claimId,
+    );
+  }
+}

package/corpus/templates/clips/actions/list-clip-views.ts

@@ -19,6 +19,7 @@ import { desc, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { displayViewerName } from "../shared/view-analytics.js";
 
 export default defineAction({
   description:
@@ -49,10 +50,7 @@ export default defineAction({
       views: rows.map((v) => ({
         id: v.id,
         viewerEmail: v.viewerEmail,
-        // Anonymous rows store the `anon:<sessionId>` dedup key in
-        // viewer_name (same convention as recording_viewers). Return null so
-        // callers render "Someone" instead of the raw session key.
-        viewerName: v.viewerName?.startsWith("anon:") ? null : v.viewerName,
+        viewerName: displayViewerName(v.viewerName),
         viewedAt: v.viewedAt,
       })),
     };

package/corpus/templates/clips/actions/list-recordings.ts

@@ -21,6 +21,7 @@ import {
 } from "../server/lib/agent-recording-access.js";
 import { resolvePlayerVideoUrl } from "../server/lib/player-video-url.js";
 import {
+  countedViewCondition,
   getActiveOrganizationId,
   ownerEmailMatches,
   parseSpaceIds,
@@ -63,6 +64,31 @@ export function resolveListRecordingMedia(
   };
 }
 
+type ViewCountRow = { recordingId: string; count: number | string | null };
+
+/**
+ * `recording_views` only exists from migration v46, so pre-migration clips have
+ * no log rows and must fall back to their counted-viewer count instead of
+ * dropping to 0. Same floor as `countRecordingViews`, so a library card and the
+ * clip page always agree.
+ */
+export function mergeViewCounts(
+  countedViewerRows: ViewCountRow[],
+  viewLogRows: ViewCountRow[],
+): Record<string, number> {
+  const merged: Record<string, number> = {};
+  for (const row of countedViewerRows) {
+    merged[row.recordingId] = Number(row.count ?? 0);
+  }
+  for (const row of viewLogRows) {
+    merged[row.recordingId] = Math.max(
+      merged[row.recordingId] ?? 0,
+      Number(row.count ?? 0),
+    );
+  }
+  return merged;
+}
+
 export default defineAction({
   description:
     "List recordings visible to the current user. Supports filtering by view (library/shared/space/archive/trash/all), folder, space, tag, free-text, and sort. Public/unlisted recordings are discoverable only when owned by or previously viewed by the current user; the shared view returns accessible recordings owned by someone else.",
@@ -229,11 +255,26 @@ export default defineAction({
     }
 
     // Sort
-    const viewCountOrder = sql<number>`(
+    const countedViewerCount = sql<number>`(
       SELECT COUNT(1)
       FROM ${schema.recordingViewers}
       WHERE ${schema.recordingViewers.recordingId} = ${schema.recordings.id}
-        AND ${eq(schema.recordingViewers.countedView, true)}
+        AND ${countedViewCondition()}
+    )`;
+    const viewLogCount = sql<number>`(
+      SELECT COUNT(1)
+      FROM ${schema.recordingViews}
+      WHERE ${schema.recordingViews.recordingId} = ${schema.recordings.id}
+    )`;
+    // Same floor as `countRecordingViews`: `recording_views` only exists from
+    // migration v46, so pre-migration clips have no log rows and must fall back
+    // to the counted-viewer count instead of sorting as zero. CASE rather than
+    // MAX()/GREATEST() — the two-argument spelling differs across dialects.
+    const viewCountOrder = sql<number>`(
+      CASE WHEN ${viewLogCount} > ${countedViewerCount}
+        THEN ${viewLogCount}
+        ELSE ${countedViewerCount}
+      END
     )`;
     const orderBy =
       args.sort === "oldest"
@@ -321,25 +362,34 @@ export default defineAction({
       }
     }
 
-    // Count views per recording
+    // Count views per recording — two set-wide grouped reads, never one per
+    // recording.
     let viewsByRec: Record<string, number> = {};
     if (ids.length) {
-      const viewRows = await db
-        .select({
-          recordingId: schema.recordingViewers.recordingId,
-          count: sql<number>`COUNT(1)`,
-        })
-        .from(schema.recordingViewers)
-        .where(
-          and(
-            inArray(schema.recordingViewers.recordingId, ids),
-            eq(schema.recordingViewers.countedView, true),
-          ),
-        )
-        .groupBy(schema.recordingViewers.recordingId);
-      for (const v of viewRows) {
-        viewsByRec[v.recordingId] = Number(v.count ?? 0);
-      }
+      const [countedViewerRows, viewLogRows] = await Promise.all([
+        db
+          .select({
+            recordingId: schema.recordingViewers.recordingId,
+            count: sql<number>`COUNT(1)`,
+          })
+          .from(schema.recordingViewers)
+          .where(
+            and(
+              inArray(schema.recordingViewers.recordingId, ids),
+              countedViewCondition(),
+            ),
+          )
+          .groupBy(schema.recordingViewers.recordingId),
+        db
+          .select({
+            recordingId: schema.recordingViews.recordingId,
+            count: sql<number>`COUNT(1)`,
+          })
+          .from(schema.recordingViews)
+          .where(inArray(schema.recordingViews.recordingId, ids))
+          .groupBy(schema.recordingViews.recordingId),
+      ]);
+      viewsByRec = mergeViewCounts(countedViewerRows, viewLogRows);
     }
 
     const recordings = rows.map((row) => {

package/corpus/templates/clips/actions/list-viewers.ts

@@ -11,7 +11,10 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { clampCompletionPct } from "../shared/view-analytics.js";
+import {
+  clampCompletionPct,
+  displayViewerName,
+} from "../shared/view-analytics.js";
 
 export default defineAction({
   description:
@@ -37,7 +40,7 @@ export default defineAction({
       .map((v) => ({
         id: v.id,
         viewerEmail: v.viewerEmail,
-        viewerName: v.viewerName,
+        viewerName: displayViewerName(v.viewerName),
         totalWatchMs: v.totalWatchMs ?? 0,
         completedPct: clampCompletionPct(v.completedPct),
         countedView: Boolean(v.countedView),

package/corpus/templates/clips/actions/regenerate-summary.ts

@@ -101,7 +101,11 @@ export default defineAction({
       `Regenerate the description for recording ${args.recordingId}. ` +
       `Read the transcript in this request's context and call ` +
       `\`update-recording --id=${args.recordingId} --description="..."\` with a 2–4 ` +
-      `sentence summary of what the recording covers. Title: "${rec.title}".`;
+      `sentence summary of what the recording covers. Title: "${rec.title}". ` +
+      `Write the description the way the person who made this recording would ` +
+      `describe it themselves: lead with the subject matter, and never use ` +
+      `outside-narrator framing like "the speaker", "the presenter", "the video", ` +
+      `"this recording", or "this clip".`;
 
     const request = {
       kind: "regenerate-summary" as const,

package/corpus/templates/clips/actions/request-transcript.ts

@@ -437,6 +437,26 @@ function fullTextSegmentJson(
   return JSON.stringify(buildCaptionSegmentsFromText(text, durationMs));
 }
 
+/**
+ * Pick the segments to store after cleanup rewrites the transcript text.
+ *
+ * Measured timings from the capture engine always win.
+ * `buildCaptionSegmentsFromText` spaces cues in proportion to word count, so
+ * re-synthesizing over real timestamps spreads a short transcript evenly across
+ * the whole recording — which reads as minute-long gaps of dropped speech even
+ * when nothing was dropped there.
+ */
+export function resolveCleanupSegmentsJson(
+  priorSegmentsJson: string | null | undefined,
+  cleanedText: string,
+  durationMs: number | null | undefined,
+): string {
+  if (parseTranscriptSegments(priorSegmentsJson).length > 1) {
+    return priorSegmentsJson as string;
+  }
+  return fullTextSegmentJson(cleanedText, durationMs);
+}
+
 export function isSafeTranscriptCleanupReplacement(
   sourceText: string,
   cleanedText: string,
@@ -642,12 +662,14 @@ async function cleanupNativeTranscript({
   ownerEmail,
   fullText,
   durationMs,
+  segmentsJson,
 }: {
   db: ReturnType<typeof getDb>;
   recordingId: string;
   ownerEmail: string;
   fullText: string;
   durationMs: number | null | undefined;
+  segmentsJson?: string | null;
 }): Promise<{ cleaned: boolean; provider?: string }> {
   const sourceText = fullText.trim();
   if (!sourceText) return { cleaned: false };
@@ -704,7 +726,11 @@ async function cleanupNativeTranscript({
         status: "ready",
         failureReason: null,
         language,
-        segmentsJson: fullTextSegmentJson(cleanedText, durationMs),
+        segmentsJson: resolveCleanupSegmentsJson(
+          segmentsJson,
+          cleanedText,
+          durationMs,
+        ),
         fullText: cleanedText,
         retryCount: 0,
         updatedAt: now,
@@ -855,6 +881,7 @@ async function completeReadyTranscript({
     ownerEmail,
     fullText,
     durationMs: recForTitle?.durationMs,
+    segmentsJson,
   }).catch((err) => {
     console.warn(
       `[clips] native transcript cleanup failed for ${recordingId}:`,

package/corpus/templates/clips/app/components/editor/stitch-manager.tsx

@@ -23,6 +23,7 @@ import {
 } from "@/components/ui/dialog";
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { exportConcat } from "@/lib/ffmpeg-export";
+import { copyRecordingShareLink } from "@/lib/recording-link";
 import { formatMs } from "@/lib/timestamp-mapping";
 import { uploadFileClient } from "@/lib/upload-file-client";
 import { cn } from "@/lib/utils";
@@ -142,7 +143,26 @@ export function StitchManager({
         videoUrl,
         durationMs: totalDuration,
       });
-      toast.success(t("stitchManager.created"));
+      const newRecordingId = (result as { id?: string } | null)?.id;
+      if (newRecordingId) {
+        const copied = await copyRecordingShareLink(newRecordingId);
+        if (copied) {
+          toast.success(t("stitchManager.created"), {
+            description: t("recordRoute.linkCopied"),
+          });
+        } else {
+          toast.success(t("stitchManager.created"), {
+            action: {
+              label: t("recordRoute.copyLinkAction"),
+              onClick: () => {
+                void copyRecordingShareLink(newRecordingId);
+              },
+            },
+          });
+        }
+      } else {
+        toast.success(t("stitchManager.created"));
+      }
       onOpenChange(false);
       return result;
     } catch (err: any) {

package/corpus/templates/clips/app/components/library/library-layout.tsx

@@ -30,7 +30,6 @@ import {
   IconLayoutSidebarLeftExpand,
   IconPlus,
   IconShare,
-  IconHierarchy2,
   IconSettings,
   IconSearch,
 } from "@tabler/icons-react";
@@ -304,12 +303,6 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
     icon: React.ComponentType<{ className?: string }>;
     match: (path: string) => boolean;
   }[] = [
-    {
-      to: "/agent",
-      label: t("settings.agentTitle"),
-      icon: IconHierarchy2,
-      match: (p) => p.startsWith("/agent"),
-    },
     {
       to: "/settings",
       label: t("navigation.settings"),

package/corpus/templates/clips/app/components/meetings/quick-ask-sidebar.tsx

@@ -78,6 +78,7 @@ export function QuickAskSidebar({
   const [open, setOpen] = useState(false);
   const [draft, setDraft] = useState("");
   const [history, setHistory] = useState<ChatTurn[]>([]);
+  const [pendingAsk, setPendingAsk] = useState<string | null>(null);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
 
   // Single global keydown listener; toggles on Cmd/Ctrl+J. Esc is handled
@@ -94,11 +95,17 @@ export function QuickAskSidebar({
     return () => window.removeEventListener("keydown", onKeyDown);
   }, []);
 
+  // The desktop pill's "Ask anything" bar hands its question over as `?ask=`
+  // alongside `?chat=1`, so the question the user typed on the overlay lands
+  // in the agent chat here instead of being retyped.
   useEffect(() => {
     const params = new URLSearchParams(window.location.search);
-    if (params.get("chat") !== "1") return;
+    const askParam = params.get("ask")?.trim();
+    if (params.get("chat") !== "1" && !askParam) return;
     setOpen(true);
+    if (askParam) setPendingAsk(askParam);
     params.delete("chat");
+    params.delete("ask");
     const nextQuery = params.toString();
     window.history.replaceState(
       window.history.state,
@@ -155,6 +162,12 @@ export function QuickAskSidebar({
     [meetingId, meetingTitle, segments, t],
   );
 
+  useEffect(() => {
+    if (!pendingAsk) return;
+    setPendingAsk(null);
+    send(pendingAsk);
+  }, [pendingAsk, send]);
+
   return (
     <Sheet open={open} onOpenChange={setOpen}>
       <SheetContent

package/corpus/templates/clips/app/components/player/insights-panel.tsx

@@ -16,8 +16,11 @@ import {
   CartesianGrid,
 } from "recharts";
 
+import {
+  ViewerAvatar,
+  viewerLabel,
+} from "@/components/player/recording-views-badge";
 import { ViewedByPopover } from "@/components/sharing/viewed-by-popover";
-import { Avatar, AvatarFallback } from "@/components/ui/avatar";
 
 export interface InsightsPanelProps {
   recordingId: string;
@@ -152,20 +155,13 @@ export function InsightsPanel({ recordingId, durationMs }: InsightsPanelProps) {
             {viewers.slice(0, 12).map((v, i) => (
               <div
                 key={i}
-                className="flex items-center gap-2 rounded-full border border-border bg-card pr-3 pl-0.5 py-0.5"
+                className="flex items-center gap-2 rounded-full border border-border bg-card pe-3 ps-0.5 py-0.5"
                 title={v.viewerEmail ?? t("recordingInsights.anonymous")}
               >
-                <Avatar className="h-6 w-6">
-                  <AvatarFallback className="text-[10px] bg-primary text-primary-foreground">
-                    {initials(v.viewerName || v.viewerEmail || "?")}
-                  </AvatarFallback>
-                </Avatar>
+                <ViewerAvatar viewer={v} />
                 <span className="text-xs">
-                  {v.viewerName ||
-                    (v.viewerEmail
-                      ? v.viewerEmail.split("@")[0]
-                      : t("recordingInsights.anon"))}
-                  <span className="text-muted-foreground ml-1">
+                  {viewerLabel(v, t("recordingInsights.anonymous"))}
+                  <span className="text-muted-foreground ms-1">
                     {Math.round(v.completedPct)}%
                   </span>
                 </span>
@@ -207,14 +203,6 @@ function Stat({
   );
 }
 
-function initials(s: string): string {
-  return s
-    .split(/\s+|@/)
-    .slice(0, 2)
-    .map((p) => p[0]?.toUpperCase() ?? "")
-    .join("");
-}
-
 function msCompact(ms: number): string {
   const s = Math.floor(ms / 1000);
   const m = Math.floor(s / 60);