@agent-native/core 0.128.0 → 0.128.2

package/corpus/templates/clips/actions/lib/direct-video.ts

@@ -0,0 +1,96 @@
+import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
+
+import { readResponseBytesWithLimit } from "./video-download-limits.js";
+
+const DIRECT_VIDEO_DOWNLOAD_TIMEOUT_MS = 120_000;
+const DIRECT_VIDEO_USER_AGENT =
+  "Mozilla/5.0 (compatible; AgentNativeClips/1.0; +https://agent-native.com)";
+
+export type DirectVideoDownload = {
+  bytes: Uint8Array;
+  mimeType: string;
+  sizeBytes: number;
+};
+
+const VIDEO_EXTENSION_MIME: Record<string, string> = {
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+};
+
+function guessMimeTypeFromUrl(sourceUrl: string): string | null {
+  let path: string;
+  try {
+    path = new URL(sourceUrl).pathname.toLowerCase();
+  } catch {
+    return null;
+  }
+  for (const [ext, mime] of Object.entries(VIDEO_EXTENSION_MIME)) {
+    if (path.endsWith(ext)) return mime;
+  }
+  return null;
+}
+
+function normalizeDirectVideoMimeType(
+  headerValue: string | null,
+  sourceUrl: string,
+): string | null {
+  const mimeType =
+    (headerValue ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  if (mimeType === "video/mp4" || mimeType === "video/webm") {
+    return mimeType;
+  }
+  if (!mimeType || mimeType === "application/octet-stream") {
+    return guessMimeTypeFromUrl(sourceUrl);
+  }
+  return null;
+}
+
+/** Any non-Loom `https://`/`http://` URL is a candidate direct video link;
+ * the real check happens after fetching, against the response content type. */
+export function isCandidateDirectVideoUrl(value: string): boolean {
+  try {
+    const parsed = new URL(value.trim());
+    return parsed.protocol === "https:" || parsed.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+
+export async function downloadDirectVideo(
+  url: string,
+): Promise<DirectVideoDownload> {
+  const response = await ssrfSafeFetch(
+    url,
+    {
+      headers: {
+        Accept: "video/mp4,video/webm,video/*;q=0.9,*/*;q=0.1",
+        "User-Agent": DIRECT_VIDEO_USER_AGENT,
+      },
+      signal: AbortSignal.timeout(DIRECT_VIDEO_DOWNLOAD_TIMEOUT_MS),
+    },
+    { maxRedirects: 3 },
+  );
+
+  if (!response.ok) {
+    throw new Error(
+      `Could not download that link (${response.status} ${response.statusText}). Make sure the URL is public and points directly to a video file.`,
+    );
+  }
+
+  const mimeType = normalizeDirectVideoMimeType(
+    response.headers.get("content-type"),
+    url,
+  );
+  if (!mimeType) {
+    throw new Error(
+      "That link doesn't point to a video file Clips can import. Paste a Loom link, or a direct link to an MP4/WebM file.",
+    );
+  }
+
+  const bytes = await readResponseBytesWithLimit(response);
+  if (bytes.byteLength <= 0) {
+    throw new Error("That link returned an empty file.");
+  }
+
+  return { bytes, mimeType, sizeBytes: bytes.byteLength };
+}

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

@@ -1,9 +1,11 @@
 import { writeAppState } from "@agent-native/core/application-state";
 import { uploadFile } from "@agent-native/core/file-upload";
-import { and, eq } from "drizzle-orm";
+import { and, asc, eq, gte, inArray } from "drizzle-orm";
 
 import { getDb, schema } from "../../server/db/index.js";
 import { queueBuilderMediaCompression } from "../../server/lib/builder-media-compression.js";
+import { ownerEmailMatches } from "../../server/lib/recordings.js";
+import { transactionalEmailStore } from "../../server/lib/transactional-email-store.js";
 import {
   extractLoomVideoId,
   normalizeLoomShareUrl,
@@ -19,6 +21,35 @@ export type LoomImportJobResult = {
   failureReason?: string;
 };
 
+export async function enqueueFirstImportEmailIfEligible(
+  input: { recordingId: string; ownerEmail: string; createdAt: string },
+  db: ReturnType<typeof getDb> = getDb(),
+): Promise<void> {
+  const { enabledAt } = await transactionalEmailStore.ensureEnabledAt();
+  if (input.createdAt < enabledAt) return;
+
+  const [firstReadyImport] = await db
+    .select({ id: schema.recordings.id })
+    .from(schema.recordings)
+    .where(
+      and(
+        ownerEmailMatches(schema.recordings.ownerEmail, input.ownerEmail),
+        eq(schema.recordings.status, "ready"),
+        inArray(schema.recordings.sourceAppName, ["Loom", "Video link"]),
+        gte(schema.recordings.createdAt, enabledAt),
+      ),
+    )
+    .orderBy(asc(schema.recordings.createdAt), asc(schema.recordings.id))
+    .limit(1);
+  if (firstReadyImport?.id !== input.recordingId) return;
+
+  await transactionalEmailStore.enqueueOrConvergeFirstImport(
+    input.ownerEmail,
+    input.recordingId,
+    input.ownerEmail,
+  );
+}
+
 export async function failLoomImport(
   recordingId: string,
   failureReason: string,
@@ -84,9 +115,15 @@ export async function runLoomImportJob({
       durationMs: schema.recordings.durationMs,
       sourceWindowTitle: schema.recordings.sourceWindowTitle,
       loomImportClaimId: schema.recordings.loomImportClaimId,
+      createdAt: schema.recordings.createdAt,
     })
     .from(schema.recordings)
-    .where(eq(schema.recordings.id, recordingId));
+    .where(
+      and(
+        eq(schema.recordings.id, recordingId),
+        ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+      ),
+    );
 
   const shareUrl = normalizeLoomShareUrl(recording?.sourceWindowTitle ?? "");
   const loomId = shareUrl ? extractLoomVideoId(shareUrl) : null;
@@ -144,6 +181,7 @@ export async function runLoomImportJob({
       .where(
         and(
           eq(schema.recordings.id, recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
           eq(schema.recordings.loomImportClaimId, claimId),
         ),
       )
@@ -216,6 +254,18 @@ export async function runLoomImportJob({
       });
     }
 
+    try {
+      await enqueueFirstImportEmailIfEligible(
+        { recordingId, ownerEmail, createdAt: recording.createdAt },
+        db,
+      );
+    } catch (err) {
+      console.warn("[clips] First-import email enqueue failed", {
+        recordingId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+
     try {
       await writeAppState(`recording-upload-${recordingId}`, {
         recordingId,
@@ -239,6 +289,7 @@ export async function runLoomImportJob({
         .where(
           and(
             eq(schema.recordings.id, recordingId),
+            ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
             eq(schema.recordings.loomImportClaimId, claimId),
           ),
         );

package/corpus/templates/clips/actions/lib/loom-video.ts

@@ -1,7 +1,8 @@
 import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
-import { MAX_UPLOAD_BYTES } from "@shared/upload-limits.js";
 import { z } from "zod";
 
+import { readResponseBytesWithLimit } from "./video-download-limits.js";
+
 const LOOM_DOWNLOAD_TIMEOUT_MS = 120_000;
 const LOOM_VIDEO_USER_AGENT =
   "Mozilla/5.0 (compatible; AgentNativeClips/1.0; +https://agent-native.com)";
@@ -29,29 +30,6 @@ export class LoomVideoUnavailableError extends Error {
   }
 }
 
-function formatBytes(bytes: number): string {
-  if (bytes >= 1024 * 1024) {
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  }
-  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${bytes} bytes`;
-}
-
-function assertUploadSize(sizeBytes: number | null | undefined): void {
-  if (!Number.isFinite(sizeBytes ?? NaN) || (sizeBytes ?? 0) <= 0) return;
-  if ((sizeBytes ?? 0) > MAX_UPLOAD_BYTES) {
-    throw new Error(
-      `Loom video is too large to import (${formatBytes(sizeBytes ?? 0)}, max ${formatBytes(MAX_UPLOAD_BYTES)}). Download a shorter or compressed copy and upload it directly.`,
-    );
-  }
-}
-
-function parseContentLength(value: string | null): number | null {
-  if (!value) return null;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : null;
-}
-
 function safeLoomDownloadUrl(value: string): string | null {
   try {
     const parsed = new URL(value);
@@ -65,44 +43,6 @@ function safeLoomDownloadUrl(value: string): string | null {
   }
 }
 
-async function readResponseBytesWithLimit(
-  response: Response,
-): Promise<Uint8Array> {
-  const contentLength = parseContentLength(
-    response.headers.get("content-length"),
-  );
-  assertUploadSize(contentLength);
-
-  if (!response.body) {
-    const arrayBuffer = await response.arrayBuffer();
-    assertUploadSize(arrayBuffer.byteLength);
-    return new Uint8Array(arrayBuffer);
-  }
-
-  const reader = response.body.getReader();
-  const chunks: Buffer[] = [];
-  let totalBytes = 0;
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (!value) continue;
-
-      totalBytes += value.byteLength;
-      assertUploadSize(totalBytes);
-      chunks.push(
-        Buffer.from(value.buffer, value.byteOffset, value.byteLength),
-      );
-    }
-  } finally {
-    reader.releaseLock();
-  }
-
-  const buffer = Buffer.concat(chunks, totalBytes);
-  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-}
-
 function normalizeVideoMimeType(value: string | null): string {
   const mimeType = (value ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
   if (!mimeType || mimeType === "application/octet-stream") return "video/mp4";

package/corpus/templates/clips/actions/lib/video-download-limits.ts

@@ -0,0 +1,62 @@
+import { MAX_UPLOAD_BYTES } from "@shared/upload-limits.js";
+
+export function formatBytes(bytes: number): string {
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${bytes} bytes`;
+}
+
+export function assertUploadSize(sizeBytes: number | null | undefined): void {
+  if (!Number.isFinite(sizeBytes ?? NaN) || (sizeBytes ?? 0) <= 0) return;
+  if ((sizeBytes ?? 0) > MAX_UPLOAD_BYTES) {
+    throw new Error(
+      `Video is too large to import (${formatBytes(sizeBytes ?? 0)}, max ${formatBytes(MAX_UPLOAD_BYTES)}). Download a shorter or compressed copy and upload it directly.`,
+    );
+  }
+}
+
+function parseContentLength(value: string | null): number | null {
+  if (!value) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : null;
+}
+
+export async function readResponseBytesWithLimit(
+  response: Response,
+): Promise<Uint8Array> {
+  const contentLength = parseContentLength(
+    response.headers.get("content-length"),
+  );
+  assertUploadSize(contentLength);
+
+  if (!response.body) {
+    const arrayBuffer = await response.arrayBuffer();
+    assertUploadSize(arrayBuffer.byteLength);
+    return new Uint8Array(arrayBuffer);
+  }
+
+  const reader = response.body.getReader();
+  const chunks: Buffer[] = [];
+  let totalBytes = 0;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+
+      totalBytes += value.byteLength;
+      assertUploadSize(totalBytes);
+      chunks.push(
+        Buffer.from(value.buffer, value.byteOffset, value.byteLength),
+      );
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const buffer = Buffer.concat(chunks, totalBytes);
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}

package/corpus/templates/clips/actions/list-transactional-email-ai-requests.ts

@@ -0,0 +1,249 @@
+import { defineAction } from "@agent-native/core/action";
+import { accessFilter, resolveAccess } from "@agent-native/core/sharing";
+import { and, eq, gte, inArray } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  getCurrentOwnerEmail,
+  ownerEmailMatches,
+} from "../server/lib/recordings.js";
+import {
+  AI_DISPATCH_STALE_MS,
+  transactionalEmailStore,
+  type TransactionalEmailJob,
+} from "../server/lib/transactional-email-store.js";
+
+const MAX_CLAIMS = 10;
+const MAX_TITLE_LENGTH = 200;
+const MAX_DESCRIPTION_LENGTH = 600;
+export const MAX_TRANSCRIPT_EXCERPT_LENGTH = 1_200;
+
+export type TransactionalEmailContextPacket = {
+  recordingId: string;
+  title: string;
+  description: string;
+  senderEmail: string;
+  transcriptExcerpt: string;
+};
+
+export type ClaimedTransactionalEmailAiRequest = {
+  jobId: string;
+  logicalKey: string;
+  contextPackets: [
+    TransactionalEmailContextPacket,
+    TransactionalEmailContextPacket,
+  ];
+};
+
+function normalizeEmail(value: string | null | undefined): string {
+  return value?.trim().toLowerCase() ?? "";
+}
+
+function boundedText(value: string | null | undefined, limit: number): string {
+  return (value ?? "").replace(/\s+/g, " ").trim().slice(0, limit);
+}
+
+async function claimantMayClaim(
+  job: TransactionalEmailJob,
+  claimantEmail: string,
+): Promise<boolean> {
+  if (normalizeEmail(job.recipient) === claimantEmail) return true;
+  if (normalizeEmail(job.requestedBy) !== claimantEmail) return false;
+
+  const access = await Promise.all(
+    job.recordingIds.map((recordingId) =>
+      resolveAccess("recording", recordingId),
+    ),
+  );
+  if (!access.every(Boolean)) return false;
+
+  const db = getDb();
+  const [directShares, countedViews] = await Promise.all([
+    db
+      .select({ recordingId: schema.recordingShares.resourceId })
+      .from(schema.recordingShares)
+      .where(
+        and(
+          eq(schema.recordingShares.principalType, "user"),
+          ownerEmailMatches(schema.recordingShares.principalId, claimantEmail),
+          inArray(schema.recordingShares.resourceId, job.recordingIds),
+        ),
+      ),
+    db
+      .select({ recordingId: schema.recordingViewers.recordingId })
+      .from(schema.recordingViewers)
+      .where(
+        and(
+          ownerEmailMatches(schema.recordingViewers.viewerEmail, claimantEmail),
+          eq(schema.recordingViewers.countedView, true),
+          inArray(schema.recordingViewers.recordingId, job.recordingIds),
+        ),
+      ),
+  ]);
+  const directlyRelatedIds = new Set([
+    ...access.flatMap((entry, index) =>
+      entry?.role === "owner" ? [job.recordingIds[index]] : [],
+    ),
+    ...directShares.map((share) => share.recordingId),
+    ...countedViews.map((view) => view.recordingId),
+  ]);
+  return job.recordingIds.every((recordingId) =>
+    directlyRelatedIds.has(recordingId),
+  );
+}
+
+async function loadContextPackets(
+  job: TransactionalEmailJob,
+  enabledAt: string,
+): Promise<
+  [TransactionalEmailContextPacket, TransactionalEmailContextPacket] | null
+> {
+  if (job.type !== "two-clips" || job.recordingIds.length !== 2) return null;
+
+  const db = getDb();
+  const [recordings, transcripts, shares] = await Promise.all([
+    db
+      .select({
+        id: schema.recordings.id,
+        title: schema.recordings.title,
+        description: schema.recordings.description,
+      })
+      .from(schema.recordings)
+      .where(
+        and(
+          inArray(schema.recordings.id, job.recordingIds),
+          accessFilter(schema.recordings, schema.recordingShares),
+        ),
+      ),
+    db
+      .select({
+        recordingId: schema.recordingTranscripts.recordingId,
+        fullText: schema.recordingTranscripts.fullText,
+      })
+      .from(schema.recordingTranscripts)
+      .where(
+        inArray(schema.recordingTranscripts.recordingId, job.recordingIds),
+      ),
+    db
+      .select({
+        id: schema.recordingShares.id,
+        recordingId: schema.recordingShares.resourceId,
+        principalId: schema.recordingShares.principalId,
+        createdBy: schema.recordingShares.createdBy,
+        createdAt: schema.recordingShares.createdAt,
+      })
+      .from(schema.recordingShares)
+      .where(
+        and(
+          eq(schema.recordingShares.principalType, "user"),
+          inArray(schema.recordingShares.resourceId, job.recordingIds),
+          gte(schema.recordingShares.createdAt, enabledAt),
+        ),
+      ),
+  ]);
+
+  const recordingById = new Map(recordings.map((row) => [row.id, row]));
+  const transcriptById = new Map(
+    transcripts.map((row) => [row.recordingId, row.fullText]),
+  );
+  const recipient = normalizeEmail(job.recipient);
+  const senderByRecordingId = new Map<string, string>();
+  for (const share of shares
+    .filter(
+      (row) =>
+        normalizeEmail(row.principalId) === recipient &&
+        row.createdAt >= enabledAt,
+    )
+    .sort(
+      (left, right) =>
+        left.createdAt.localeCompare(right.createdAt) ||
+        left.id.localeCompare(right.id),
+    )) {
+    if (!senderByRecordingId.has(share.recordingId)) {
+      senderByRecordingId.set(
+        share.recordingId,
+        normalizeEmail(share.createdBy),
+      );
+    }
+  }
+
+  const packets = job.recordingIds.map((recordingId) => {
+    const recording = recordingById.get(recordingId);
+    const senderEmail = senderByRecordingId.get(recordingId);
+    if (!recording || !senderEmail) return null;
+    return {
+      recordingId,
+      title: boundedText(recording.title, MAX_TITLE_LENGTH),
+      description: boundedText(recording.description, MAX_DESCRIPTION_LENGTH),
+      senderEmail,
+      transcriptExcerpt: boundedText(
+        transcriptById.get(recordingId),
+        MAX_TRANSCRIPT_EXCERPT_LENGTH,
+      ),
+    };
+  });
+
+  return packets.length === 2 && packets[0] && packets[1]
+    ? [packets[0], packets[1]]
+    : null;
+}
+
+export async function claimTransactionalEmailAiRequests(
+  claimantEmail: string,
+  limit = MAX_CLAIMS,
+): Promise<{ requests: ClaimedTransactionalEmailAiRequest[] }> {
+  const claimant = normalizeEmail(claimantEmail);
+  const claimLimit = Math.min(Math.max(limit, 1), MAX_CLAIMS);
+  const config = await transactionalEmailStore.readConfig();
+  if (!config) return { requests: [] };
+  const staleBefore = new Date(Date.now() - AI_DISPATCH_STALE_MS);
+  const candidates = (await transactionalEmailStore.listJobs()).filter(
+    (job) =>
+      job.type === "two-clips" &&
+      (job.state === "awaiting_ai" ||
+        (job.state === "ai_dispatched" &&
+          Date.parse(job.aiDispatchedAt ?? job.updatedAt) <=
+            staleBefore.getTime())) &&
+      job.recordingIds.length === 2,
+  );
+  const requests: ClaimedTransactionalEmailAiRequest[] = [];
+
+  for (const candidate of candidates) {
+    if (requests.length >= claimLimit) break;
+    if (!(await claimantMayClaim(candidate, claimant))) continue;
+    const contextPackets = await loadContextPackets(
+      candidate,
+      config.enabledAt,
+    );
+    if (!contextPackets) continue;
+    const claimed =
+      candidate.state === "awaiting_ai"
+        ? await transactionalEmailStore.claimAwaitingAi(
+            candidate.logicalKey,
+            claimant,
+          )
+        : await transactionalEmailStore.reclaimStaleAiDispatch(
+            candidate.logicalKey,
+            claimant,
+            staleBefore,
+          );
+    if (!claimed) continue;
+    requests.push({
+      jobId: claimed.logicalKey,
+      logicalKey: claimed.logicalKey,
+      contextPackets,
+    });
+  }
+
+  return { requests };
+}
+
+export default defineAction({
+  description:
+    "Claim bounded two-Clip transactional email summary work for the signed-in Clips UI.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  agentTool: false,
+  run: async () => claimTransactionalEmailAiRequests(getCurrentOwnerEmail()),
+});

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

@@ -7,8 +7,12 @@ import {
   IconAlertTriangle,
   IconChevronLeft,
   IconChevronRight,
+  IconPlayerRecord,
+  IconUpload,
+  IconLink,
 } from "@tabler/icons-react";
 import { useCallback, useEffect, useMemo, useState } from "react";
+import { NavLink } from "react-router";
 import { toast } from "sonner";
 
 import { CreateFolderDialog } from "@/components/library/create-folder-dialog";
@@ -59,6 +63,64 @@ function Skeleton() {
   );
 }
 
+function NewRecordingTile({
+  spaceId,
+  folderId,
+}: {
+  spaceId?: string | null;
+  folderId?: string | null;
+}) {
+  const t = useT();
+  const recordHref = useMemo(() => {
+    const params = new URLSearchParams();
+    if (spaceId) params.set("spaceId", spaceId);
+    if (folderId) params.set("folderId", folderId);
+    const qs = params.toString();
+    return qs ? `/record?${qs}` : "/record";
+  }, [spaceId, folderId]);
+  const uploadHref = useMemo(() => {
+    const params = new URLSearchParams();
+    if (spaceId) params.set("spaceId", spaceId);
+    if (folderId) params.set("folderId", folderId);
+    params.set("autoUpload", "1");
+    return `/record?${params.toString()}`;
+  }, [spaceId, folderId]);
+  const importHref = useMemo(() => {
+    const params = new URLSearchParams();
+    if (spaceId) params.set("spaceId", spaceId);
+    if (folderId) params.set("folderId", folderId);
+    const qs = params.toString();
+    return qs ? `/import?${qs}` : "/import";
+  }, [spaceId, folderId]);
+
+  return (
+    <div className="flex flex-col items-center justify-center gap-3 rounded-lg border border-dashed border-border bg-muted/20 p-6 text-center transition-colors hover:border-primary/40 hover:bg-muted/40">
+      <Button className="w-full max-w-[180px] gap-1.5" size="sm" asChild>
+        <NavLink to={recordHref}>
+          <IconPlayerRecord className="h-4 w-4" />
+          {t("navigation.newRecording")}
+        </NavLink>
+      </Button>
+      <div className="flex items-center gap-3">
+        <NavLink
+          to={uploadHref}
+          className="flex items-center gap-1.5 text-xs font-medium text-muted-foreground hover:text-foreground"
+        >
+          <IconUpload className="h-3.5 w-3.5" />
+          {t("preRecord.uploadVideo")}
+        </NavLink>
+        <NavLink
+          to={importHref}
+          className="flex items-center gap-1.5 text-xs font-medium text-muted-foreground hover:text-foreground"
+        >
+          <IconLink className="h-3.5 w-3.5" />
+          {t("preRecord.importLoom")}
+        </NavLink>
+      </div>
+    </div>
+  );
+}
+
 const PAGE_SIZE = 100;
 
 interface FolderTargetRow {
@@ -491,6 +553,9 @@ export function LibraryGrid({
                     readOnly={!canManageRecordings}
                   />
                 ))}
+                {view === "library" && page === totalPages && (
+                  <NewRecordingTile spaceId={spaceId} folderId={folderId} />
+                )}
               </div>
             )}
           </div>