@agent-native/core 0.128.0 → 0.128.2

package/corpus/templates/clips/AGENTS.md

@@ -44,6 +44,11 @@ Read the matching skill before deeper work in that area:
   activation. Navigate the user to the recording view instead of a server action.
 - Native transcript first; cloud transcription is fallback-only. Never hide a
   usable native transcript behind failed metadata work.
+- Use `import-loom-recording` for Loom or direct MP4/WebM URLs. Loom media and
+  public transcripts import in the background; direct videos need
+  `request-transcript` afterward.
+- Internal transactional-email actions claim bounded two-Clip summary work and
+  complete it with one plain-text sentence after reviewing both context packets.
 - The `view-screen` transcript is a bounded preview: when `previewTruncated` is
   true it may end mid-sentence and says nothing about where transcription
   ended. Call `get-recording-player-data` before judging completeness or
@@ -82,7 +87,7 @@ Read the matching skill before deeper work in that area:
 | `list-recordings`, `search-recordings` | Library, trash, `--view=shared` |
 | `get-recording-player-data` | Full transcript, chapters, diagnostics |
 | `create-recording`, `finalize-recording` | Create row; finish upload |
-| `import-loom-recording` | Import a Loom share/embed URL |
+| `import-loom-recording` | Import Loom or direct MP4/WebM URL |
 | `update-recording` | Title, password, expiry, visibility |
 | `move-recording` | Move `id` or `ids` to a folder or root |
 | `archive-`, `trash-`, `restore-recording` | Lifecycle |

package/corpus/templates/clips/_gitignore

@@ -8,8 +8,10 @@ npm-debug.log*
 pnpm-debug.log*
 
 node_modules
+build/
 dist
 dist-ssr
+.output/
 *.local
 
 # Editor directories and files

package/corpus/templates/clips/actions/complete-transactional-email-summary.ts

@@ -0,0 +1,56 @@
+import { defineAction } from "@agent-native/core/action";
+import { z } from "zod";
+
+import { getCurrentOwnerEmail } from "../server/lib/recordings.js";
+import { transactionalEmailStore } from "../server/lib/transactional-email-store.js";
+
+export const MAX_TRANSACTIONAL_EMAIL_SUMMARY_LENGTH = 320;
+
+export function normalizeTransactionalEmailSummary(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+export function validateTransactionalEmailSummary(value: string): string {
+  const summary = normalizeTransactionalEmailSummary(value);
+  if (!summary) throw new Error("Summary must be one nonempty sentence.");
+  if (summary.length > MAX_TRANSACTIONAL_EMAIL_SUMMARY_LENGTH) {
+    throw new Error(
+      `Summary must be at most ${MAX_TRANSACTIONAL_EMAIL_SUMMARY_LENGTH} characters.`,
+    );
+  }
+  if (/[<>]/.test(summary)) {
+    throw new Error("Summary must be plain text without HTML.");
+  }
+  const sentenceEndings = summary.match(/[.!?](?=\s|$)/g) ?? [];
+  if (sentenceEndings.length !== 1 || !/[.!?]$/.test(summary)) {
+    throw new Error("Summary must be exactly one sentence.");
+  }
+  return summary;
+}
+
+export default defineAction({
+  description:
+    "Complete only the claimed two-Clip transactional email summary workflow.",
+  schema: z.object({
+    jobId: z.string().trim().min(1),
+    summary: z.string().max(2_000),
+  }),
+  run: async ({ jobId, summary }) => {
+    const claimantEmail = getCurrentOwnerEmail().trim().toLowerCase();
+    const normalizedSummary = validateTransactionalEmailSummary(summary);
+    const completed = await transactionalEmailStore.completeClaimedAi(
+      jobId,
+      claimantEmail,
+      normalizedSummary,
+    );
+    if (!completed) {
+      throw new Error("This transactional email AI claim is unavailable.");
+    }
+    return {
+      jobId: completed.logicalKey,
+      logicalKey: completed.logicalKey,
+      state: completed.state,
+      generatedSummary: completed.generatedSummary,
+    };
+  },
+});

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

@@ -1,12 +1,14 @@
 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,
@@ -18,7 +20,16 @@ import {
   stringifySpaceIds,
 } from "../server/lib/recordings.js";
 import { hasRequestVideoStorage } from "../server/lib/video-storage.js";
-import { failLoomImport } from "./lib/loom-import-job.js";
+import {
+  downloadDirectVideo,
+  isCandidateDirectVideoUrl,
+} from "./lib/direct-video.js";
+import {
+  enqueueFirstImportEmailIfEligible,
+  failLoomImport,
+} from "./lib/loom-import-job.js";
+
+export { enqueueFirstImportEmailIfEligible };
 
 const LoomOembedSchema = z
   .object({
@@ -42,14 +53,16 @@ const ImportLoomRecordingSchema = z.object({
     .min(1)
     .max(2048)
     .describe(
-      "Loom share or embed URL, such as https://www.loom.com/share/...",
+      "Loom share/embed URL, or a direct link to an MP4/WebM video file",
     ),
   title: z
     .string()
     .trim()
     .max(200)
     .optional()
-    .describe("Optional title override; defaults to Loom's oEmbed title"),
+    .describe(
+      "Optional title override; defaults to Loom's oEmbed title when available",
+    ),
   folderId: z.string().nullish().describe("Optional folder ID"),
   spaceIds: z
     .array(z.string().min(1))
@@ -71,12 +84,14 @@ const ImportLoomRecordingSchema = z.object({
     .string()
     .optional()
     .describe(
-      "Existing waiting Loom recording ID to retry after storage is connected",
+      "Existing waiting recording ID to retry after storage is connected",
     ),
 });
 
 const LOOM_STORAGE_SETUP_REQUIRED_REASON =
   "Video storage is not connected yet. Connect Builder.io or configure S3-compatible storage, then retry this Loom import.";
+const DIRECT_VIDEO_STORAGE_SETUP_REQUIRED_REASON =
+  "Video storage is not connected yet. Connect Builder.io or configure S3-compatible storage, then retry this import.";
 
 function recordingDeepLink(recordingId: string): string {
   return buildDeepLink({
@@ -127,14 +142,26 @@ async function fetchLoomOembed(shareUrl: string) {
 
 export default defineAction({
   description:
-    "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.",
+    "Import a public Loom share URL, or a direct link to a video file, into Clips as a playable recording. Loom links create the recording immediately and download/reupload Loom's public MP4 plus import Loom's public transcript in the background, since Loom's CDN plus a reupload can take longer than a single request should block on. Other direct video links (e.g. an MP4/WebM/MOV hosted by another screen recorder) are downloaded and reuploaded synchronously without transcript metadata — use request-transcript afterward. 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);
     const loomId = extractLoomVideoId(args.url);
-    if (!shareUrl || !loomId) {
+    const isLoom = Boolean(loomId);
+    const loomShareUrl = isLoom ? normalizeLoomShareUrl(args.url) : null;
+    if (isLoom && !loomShareUrl) {
       throw new Error("Paste a Loom share or embed URL.");
     }
+    if (!isLoom && !isCandidateDirectVideoUrl(args.url)) {
+      throw new Error(
+        "Paste a Loom share URL, or a direct link to a video file.",
+      );
+    }
+    const sourceUrl = isLoom ? loomShareUrl! : args.url.trim();
+    const sourceAppName = isLoom ? "Loom" : "Video link";
+    const storageSetupReason = isLoom
+      ? LOOM_STORAGE_SETUP_REQUIRED_REASON
+      : DIRECT_VIDEO_STORAGE_SETUP_REQUIRED_REASON;
+    const providerId = isLoom ? ("loom" as const) : ("video-link" as const);
 
     const db = getDb();
     const ownerEmail = getCurrentOwnerEmail();
@@ -150,25 +177,36 @@ export default defineAction({
           ),
         );
       if (!existingRecording) {
-        throw new Error("Waiting Loom recording not found.");
+        throw new Error("Waiting recording not found.");
       }
-      if (existingRecording.sourceAppName?.trim().toLowerCase() !== "loom") {
-        throw new Error("Only Loom recordings can be retried this way.");
+      if (
+        existingRecording.sourceAppName?.trim().toLowerCase() !==
+        sourceAppName.toLowerCase()
+      ) {
+        throw new Error(
+          "Only a matching waiting import can be retried this way.",
+        );
       }
-      const existingSourceUrl = normalizeLoomShareUrl(
-        existingRecording.sourceWindowTitle ?? "",
-      );
+      const isWaitingStorageRetry =
+        existingRecording.status === "uploading" &&
+        !existingRecording.videoUrl &&
+        existingRecording.failureReason === storageSetupReason &&
+        existingRecording.sourceWindowTitle === sourceUrl;
       const isRetryableLoomImport =
+        isLoom &&
         !existingRecording.videoUrl &&
-        existingSourceUrl === shareUrl &&
+        existingRecording.sourceWindowTitle === sourceUrl &&
         (existingRecording.status === "processing" ||
           existingRecording.status === "failed" ||
-          (existingRecording.status === "uploading" &&
-            existingRecording.failureReason ===
-              LOOM_STORAGE_SETUP_REQUIRED_REASON));
-      if (!isRetryableLoomImport) {
+          isWaitingStorageRetry);
+      const isRetryable = isLoom
+        ? isRetryableLoomImport
+        : isWaitingStorageRetry;
+      if (!isRetryable) {
         throw new Error(
-          "Only an incomplete Loom import can be retried in place.",
+          isLoom
+            ? "Only an incomplete Loom import can be retried in place."
+            : "Only a waiting-storage import can be retried in place.",
         );
       }
     }
@@ -181,7 +219,8 @@ export default defineAction({
 
     const now = new Date().toISOString();
     const id = existingRecording?.id ?? nanoid();
-    const oembed = await fetchLoomOembed(shareUrl);
+    const createdAt = existingRecording?.createdAt ?? now;
+    const oembed = isLoom ? await fetchLoomOembed(loomShareUrl!) : null;
 
     const spaceIds = (
       args.spaceIds ?? parseSpaceIds(existingRecording?.spaceIds)
@@ -192,11 +231,13 @@ export default defineAction({
       existingRecording.title !== "Untitled recording"
         ? existingRecording.title
         : null) ||
-      oembed.title?.trim() ||
-      `Loom recording ${loomId.slice(0, 8)}`;
-    const durationMs = boundedDurationMs(oembed.duration);
-    const width = boundedDimension(oembed.width ?? oembed.thumbnail_width);
-    const height = boundedDimension(oembed.height ?? oembed.thumbnail_height);
+      oembed?.title?.trim() ||
+      (isLoom
+        ? `Loom recording ${loomId!.slice(0, 8)}`
+        : `Imported video ${id.slice(0, 8)}`);
+    const durationMs = boundedDurationMs(oembed?.duration);
+    const width = boundedDimension(oembed?.width ?? oembed?.thumbnail_width);
+    const height = boundedDimension(oembed?.height ?? oembed?.thumbnail_height);
     const folderId = args.folderId ?? existingRecording?.folderId ?? null;
     const visibility =
       args.visibility ?? existingRecording?.visibility ?? defaultVisibility;
@@ -204,20 +245,23 @@ export default defineAction({
       ? "manual"
       : (existingRecording?.titleSource ?? "upload");
 
-    const buildRecordingValues = (videoSizeBytes: number) => ({
+    const buildRecordingValues = (
+      videoSizeBytes: number,
+      videoFormat: "mp4" | "webm" = "mp4",
+    ) => ({
       organizationId,
       orgId: organizationId,
       folderId,
       spaceIds: stringifySpaceIds(spaceIds),
       title,
       titleSource,
-      sourceAppName: "Loom",
-      sourceWindowTitle: shareUrl,
+      sourceAppName,
+      sourceWindowTitle: sourceUrl,
       description: existingRecording?.description ?? "",
       thumbnailUrl:
-        oembed.thumbnail_url ?? existingRecording?.thumbnailUrl ?? null,
+        oembed?.thumbnail_url ?? existingRecording?.thumbnailUrl ?? null,
       durationMs,
-      videoFormat: "mp4" as const,
+      videoFormat,
       videoSizeBytes,
       width,
       height,
@@ -237,7 +281,7 @@ export default defineAction({
             ...recordingValues,
             status: "uploading",
             videoUrl: null,
-            failureReason: LOOM_STORAGE_SETUP_REQUIRED_REASON,
+            failureReason: storageSetupReason,
             loomImportClaimId: null,
             loomImportClaimedAt: null,
           })
@@ -248,19 +292,19 @@ export default defineAction({
           ...recordingValues,
           videoUrl: null,
           status: "uploading",
-          failureReason: LOOM_STORAGE_SETUP_REQUIRED_REASON,
+          failureReason: storageSetupReason,
           ownerEmail,
-          createdAt: now,
+          createdAt,
         });
       }
 
       await writeAppState(`recording-upload-${id}`, {
         recordingId: id,
         status: "waiting_storage",
-        failureReason: LOOM_STORAGE_SETUP_REQUIRED_REASON,
+        failureReason: storageSetupReason,
         progress: 100,
-        provider: "loom",
-        sourceUrl: shareUrl,
+        provider: providerId,
+        sourceUrl,
         durationMs,
         width,
         height,
@@ -276,13 +320,13 @@ export default defineAction({
         title,
         status: "waiting_storage" as const,
         storageSetupRequired: true,
-        provider: "loom" as const,
-        sourceUrl: shareUrl,
-        thumbnailUrl: oembed.thumbnail_url ?? null,
+        provider: providerId,
+        sourceUrl,
+        thumbnailUrl: oembed?.thumbnail_url ?? null,
         durationMs,
         importMode: "reuploaded" as const,
         videoSizeBytes,
-        note: LOOM_STORAGE_SETUP_REQUIRED_REASON,
+        note: storageSetupReason,
       };
     };
 
@@ -292,22 +336,115 @@ export default defineAction({
       );
     }
 
-    // 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 (isLoom) {
+      // Storage is connected: create/refresh the row now and hand the slow
+      // Loom download + reupload + transcript off to a durable background
+      // job (post-finalize-worker.post.ts's "loom-import" kind /
+      // runLoomImportJob). Loom's CDN plus a reupload can outlast a single
+      // request; the worker claims the row (loomImportClaimId) and moves it
+      // to "ready" or "failed" once done.
+      const recordingValues = buildRecordingValues(
+        existingRecording?.videoSizeBytes ?? 0,
+      );
+      if (existingRecording) {
+        await db
+          .update(schema.recordings)
+          .set({
+            ...recordingValues,
+            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: null,
+          status: "processing",
+          failureReason: null,
+          ownerEmail,
+          createdAt,
+        });
+      }
+
+      await writeAppState(`recording-upload-${id}`, {
+        recordingId: id,
+        status: "processing",
+        progress: 100,
+        provider: providerId,
+        sourceUrl,
+        durationMs,
+        width,
+        height,
+        hasAudio: true,
+        hasCamera: false,
+        updatedAt: now,
+      });
+      await writeAppState("refresh-signal", { ts: Date.now() });
+      await writeAppState("navigate", { view: "recording", recordingId: id });
+
+      try {
+        await dispatchPostFinalizeJob({
+          recordingId: id,
+          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);
+      }
+
+      return {
+        recordingId: id,
+        title,
+        status: "processing" as const,
+        provider: providerId,
+        sourceUrl,
+        thumbnailUrl: oembed?.thumbnail_url ?? null,
+        durationMs,
+        importMode: "reuploaded" as const,
+        note: "Downloading and importing this Loom recording in the background.",
+      };
+    }
+
+    // Direct video links stay synchronous: they typically download and
+    // reupload well within a single request, and this keeps
+    // request-transcript as the deliberate next step for a transcript.
+    const media = await downloadDirectVideo(sourceUrl);
+    const videoFormat = media.mimeType === "video/webm" ? "webm" : "mp4";
+    const upload = await uploadFile({
+      data: media.bytes,
+      filename: `${id}.${videoFormat}`,
+      mimeType: media.mimeType,
+      ownerEmail,
+      stableUrl: true,
+      recordAsset: false,
+    });
+
+    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;
+    const recordingValues = buildRecordingValues(media.sizeBytes, videoFormat);
     if (existingRecording) {
       await db
         .update(schema.recordings)
         .set({
           ...recordingValues,
-          status: "processing",
-          videoUrl: null,
+          status: "ready",
+          videoUrl,
           failureReason: null,
           loomImportClaimId: null,
           loomImportClaimedAt: null,
@@ -317,20 +454,75 @@ export default defineAction({
       await db.insert(schema.recordings).values({
         id,
         ...recordingValues,
-        videoUrl: null,
-        status: "processing",
+        videoUrl,
+        status: "ready",
         failureReason: null,
         ownerEmail,
+        createdAt,
+      });
+    }
+
+    void queueBuilderMediaCompression({
+      recordingId: id,
+      ownerEmail,
+      videoUrl,
+      mimeType: media.mimeType,
+      providerId: upload.provider,
+      assetDbId: upload.id,
+      sourceSizeBytes: media.sizeBytes,
+    }).catch((err) => {
+      console.warn("[clips] Video import media compression queue failed", {
+        recordingId: id,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    });
+
+    const transcriptValues = {
+      ownerEmail,
+      language: "en",
+      segmentsJson: "[]",
+      fullText: "",
+      status: "failed" as const,
+      failureReason:
+        "Transcript import isn't available for direct video links yet. Use request-transcript to transcribe the uploaded media.",
+      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({
+        recordingId: id,
+        ...transcriptValues,
         createdAt: now,
       });
     }
 
+    try {
+      await enqueueFirstImportEmailIfEligible(
+        { recordingId: id, ownerEmail, createdAt },
+        db,
+      );
+    } catch (err) {
+      console.warn("[clips] First-import email enqueue failed", {
+        recordingId: id,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+
     await writeAppState(`recording-upload-${id}`, {
       recordingId: id,
-      status: "processing",
+      status: "ready",
       progress: 100,
-      provider: "loom",
-      sourceUrl: shareUrl,
+      videoUrl,
+      provider: providerId,
+      sourceUrl,
       durationMs,
       width,
       height,
@@ -341,30 +533,20 @@ export default defineAction({
     await writeAppState("refresh-signal", { ts: Date.now() });
     await writeAppState("navigate", { view: "recording", recordingId: id });
 
-    try {
-      await dispatchPostFinalizeJob({
-        recordingId: id,
-        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);
-    }
-
     return {
       recordingId: id,
       title,
-      status: "processing" as const,
-      provider: "loom" as const,
-      sourceUrl: shareUrl,
-      thumbnailUrl: oembed.thumbnail_url ?? null,
+      status: "ready" as const,
+      provider: providerId,
+      sourceUrl,
+      videoUrl,
+      embedUrl: videoUrl,
+      thumbnailUrl: oembed?.thumbnail_url ?? null,
       durationMs,
       importMode: "reuploaded" as const,
-      note: "Downloading and importing this Loom recording in the background.",
+      storageProvider: upload.provider,
+      videoSizeBytes: media.sizeBytes,
+      note: "Imported as a Clips-hosted video. Use request-transcript to transcribe the uploaded media.",
     };
   },
   link: ({ result }) => {
@@ -373,7 +555,7 @@ export default defineAction({
     if (typeof recordingId !== "string") return null;
     return {
       url: recordingDeepLink(recordingId),
-      label: "Open imported Loom clip in Clips",
+      label: "Open imported clip in Clips",
       view: "recording",
     };
   },