@agent-native/core 0.109.0 → 0.109.2

package/corpus/templates/clips/server/jobs/media-verification.ts

@@ -0,0 +1,130 @@
+import { getDbExec } from "@agent-native/core/db";
+import { runWithRequestContext } from "@agent-native/core/server";
+import { and, eq, isNull } from "drizzle-orm";
+
+import finalizeRecording from "../../actions/finalize-recording.js";
+import { getDb, schema } from "../db/index.js";
+import {
+  MEDIA_VERIFICATION_STATE_PREFIX,
+  parseMediaVerificationMarker,
+} from "../lib/media-verification-state.js";
+import { ownerEmailMatches } from "../lib/recordings.js";
+
+const SWEEP_INTERVAL_MS = 60_000;
+const DISPATCH_FALLBACK_GRACE_MS = 30_000;
+const MAX_ATTEMPTS = 10;
+let skippingLogged = false;
+
+export async function runMediaVerificationSweepOnce(): Promise<void> {
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT session_id, key, value FROM application_state WHERE key LIKE ?`,
+    args: [`${MEDIA_VERIFICATION_STATE_PREFIX}%`],
+  });
+  const now = Date.now();
+
+  for (const row of rows as Array<{
+    session_id?: unknown;
+    key?: unknown;
+    value?: unknown;
+  }>) {
+    const sessionId =
+      typeof row.session_id === "string" ? row.session_id.trim() : "";
+    const key = typeof row.key === "string" ? row.key : "";
+    const recordingId = key.startsWith(MEDIA_VERIFICATION_STATE_PREFIX)
+      ? key.slice(MEDIA_VERIFICATION_STATE_PREFIX.length)
+      : "";
+    const rawValue = typeof row.value === "string" ? row.value : "";
+    let rawState: unknown;
+    try {
+      rawState = JSON.parse(rawValue);
+    } catch {
+      continue;
+    }
+    const marker = parseMediaVerificationMarker(rawState);
+    if (
+      !sessionId ||
+      !recordingId ||
+      !marker ||
+      marker.recordingId !== recordingId
+    ) {
+      continue;
+    }
+
+    const nextAttemptAt = Date.parse(marker.nextAttemptAt);
+    const leaseUntil = marker.leaseUntil
+      ? Date.parse(marker.leaseUntil)
+      : Number.NEGATIVE_INFINITY;
+    const due =
+      marker.status === "pending"
+        ? now >= nextAttemptAt + DISPATCH_FALLBACK_GRACE_MS
+        : now >= leaseUntil;
+    if (marker.completedAttempts >= MAX_ATTEMPTS || !due) {
+      continue;
+    }
+
+    try {
+      const [recording] = await getDb()
+        .select({
+          ownerEmail: schema.recordings.ownerEmail,
+          orgId: schema.recordings.orgId,
+        })
+        .from(schema.recordings)
+        .where(
+          and(
+            eq(schema.recordings.id, recordingId),
+            ownerEmailMatches(schema.recordings.ownerEmail, sessionId),
+            eq(schema.recordings.status, "processing"),
+            isNull(schema.recordings.trashedAt),
+          ),
+        )
+        .limit(1);
+      if (!recording) continue;
+
+      await runWithRequestContext(
+        {
+          userEmail: recording.ownerEmail,
+          orgId: recording.orgId ?? undefined,
+        },
+        async () => {
+          await finalizeRecording.run({
+            id: recordingId,
+            mediaVerificationRetryAttempt: Math.min(
+              MAX_ATTEMPTS,
+              marker.completedAttempts + 1,
+            ),
+          });
+        },
+      );
+    } catch (err) {
+      console.warn("[media-verification] sweep item failed", {
+        key: String(row.key ?? ""),
+        recordingId,
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+}
+
+export default function registerMediaVerificationJob(): void {
+  const isProd = process.env.NODE_ENV === "production";
+  const flag = process.env.RUN_BACKGROUND_JOBS;
+  const enabled = flag === "1" || (isProd && flag !== "0");
+  if (!enabled) {
+    if (process.env.DEBUG && !skippingLogged) {
+      console.log(
+        "[media-verification] Skipping background sweep (set RUN_BACKGROUND_JOBS=1 to enable in dev).",
+      );
+      skippingLogged = true;
+    }
+    return;
+  }
+
+  setInterval(() => {
+    runMediaVerificationSweepOnce().catch((err) =>
+      console.error("[media-verification] interval failed:", err),
+    );
+  }, SWEEP_INTERVAL_MS);
+  console.log(
+    `[media-verification] Recurring recovery sweep every ${SWEEP_INTERVAL_MS / 1000}s.`,
+  );
+}

package/corpus/templates/clips/server/lib/builder-media-compression.ts

@@ -9,7 +9,7 @@ import {
   resolveBuilderPrivateKey,
   runWithRequestContext,
 } from "@agent-native/core/server";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 
 import type { MediaWorkerCallback } from "../../shared/media-worker-contract.js";
 import { getDb, schema } from "../db/index.js";
@@ -648,6 +648,21 @@ async function processCompressionState(
   try {
     const compressed = await triggerBuilderCompression(state);
     if (compressed) {
+      if (!compressed.durationMs) {
+        if (attempts >= MAX_TRIGGER_ATTEMPTS) {
+          return markCompressionFailed(
+            { ...state, attempts },
+            `Builder media compression did not provide a verified duration after ${attempts} attempts`,
+          );
+        }
+        return writeCompressionState(state, {
+          status: "triggered",
+          attempts,
+          lastTriggeredAt: new Date().toISOString(),
+          nextAttemptAt: isoAfter(TRIGGERED_POLL_DELAY_MS),
+          detail: "Compressed media is not ready with a verified duration yet",
+        });
+      }
       return swapRecordingToCompressed(
         state,
         compressed.url,
@@ -943,7 +958,12 @@ export async function runBuilderMediaCompressionSweepOnce(): Promise<void> {
     key?: unknown;
     value?: unknown;
   }>) {
-    const sessionId = typeof row.session_id === "string" ? row.session_id : "";
+    const sessionId =
+      typeof row.session_id === "string" ? row.session_id.trim() : "";
+    const key = typeof row.key === "string" ? row.key : "";
+    const recordingId = key.startsWith(BUILDER_MEDIA_COMPRESSION_STATE_PREFIX)
+      ? key.slice(BUILDER_MEDIA_COMPRESSION_STATE_PREFIX.length)
+      : "";
     const rawValue = typeof row.value === "string" ? row.value : "";
     let value: Record<string, unknown> | null = null;
     try {
@@ -952,14 +972,61 @@ export async function runBuilderMediaCompressionSweepOnce(): Promise<void> {
       continue;
     }
     const state = parseState(value);
-    if (!state || isFinalStatus(state.status) || !isDue(state)) continue;
-    const ownerEmail = state.ownerEmail || sessionId;
-    if (!ownerEmail) continue;
+    if (
+      !sessionId ||
+      !recordingId ||
+      !state ||
+      state.recordingId !== recordingId ||
+      isFinalStatus(state.status) ||
+      !isDue(state)
+    ) {
+      continue;
+    }
     try {
+      const [recording] = await getDb()
+        .select({
+          ownerEmail: schema.recordings.ownerEmail,
+          orgId: schema.recordings.orgId,
+          videoUrl: schema.recordings.videoUrl,
+        })
+        .from(schema.recordings)
+        .where(
+          and(
+            eq(schema.recordings.id, recordingId),
+            ownerEmailMatches(schema.recordings.ownerEmail, sessionId),
+            eq(schema.recordings.status, "ready"),
+            isNull(schema.recordings.trashedAt),
+          ),
+        )
+        .limit(1);
+      const expectedTarget = extractBuilderMediaTarget(
+        recording?.videoUrl ?? "",
+      );
+      if (
+        !recording ||
+        !expectedTarget ||
+        state.sourceUrl !== expectedTarget.sourceUrl ||
+        (state.mediaWorker &&
+          (state.mediaWorker.jobId !==
+            mediaWorkerCompressionJobId(recordingId) ||
+            state.mediaWorker.outputUrl !== expectedTarget.compressedUrl))
+      ) {
+        continue;
+      }
+
+      const trustedState: BuilderMediaCompressionState = {
+        ...state,
+        ...expectedTarget,
+        ownerEmail: recording.ownerEmail,
+        orgId: recording.orgId,
+      };
       await runWithRequestContext(
-        { userEmail: ownerEmail, orgId: state.orgId ?? undefined },
+        {
+          userEmail: recording.ownerEmail,
+          orgId: recording.orgId ?? undefined,
+        },
         async () => {
-          await processCompressionState({ ...state, ownerEmail });
+          await processCompressionState(trustedState);
         },
       );
     } catch (err) {

package/corpus/templates/clips/server/lib/media-verification-state.ts

@@ -0,0 +1,55 @@
+import { appStateGet } from "@agent-native/core/application-state";
+
+export const MEDIA_VERIFICATION_STATE_PREFIX = "recording-media-verification-";
+
+export type MediaVerificationMarker = {
+  recordingId: string;
+  status: "pending" | "leased";
+  completedAttempts: number;
+  nextAttemptAt: string;
+  leaseUntil: string | null;
+  updatedAt: string;
+};
+
+export function mediaVerificationStateKey(recordingId: string): string {
+  return `${MEDIA_VERIFICATION_STATE_PREFIX}${recordingId}`;
+}
+
+export function parseMediaVerificationMarker(
+  value: unknown,
+): MediaVerificationMarker | null {
+  if (!value || typeof value !== "object") return null;
+  const state = value as Record<string, unknown>;
+  if (
+    typeof state.recordingId !== "string" ||
+    !state.recordingId ||
+    (state.status !== "pending" && state.status !== "leased") ||
+    typeof state.completedAttempts !== "number" ||
+    !Number.isInteger(state.completedAttempts) ||
+    state.completedAttempts < 0 ||
+    typeof state.nextAttemptAt !== "string" ||
+    !Number.isFinite(Date.parse(state.nextAttemptAt)) ||
+    (state.leaseUntil !== null &&
+      (typeof state.leaseUntil !== "string" ||
+        !Number.isFinite(Date.parse(state.leaseUntil)))) ||
+    typeof state.updatedAt !== "string"
+  ) {
+    return null;
+  }
+  return state as MediaVerificationMarker;
+}
+
+export async function isMediaVerificationPending(args: {
+  ownerEmail: string;
+  recordingId: string;
+  recordingStatus: string;
+}): Promise<boolean> {
+  if (args.recordingStatus !== "processing") return false;
+
+  const value = await appStateGet(
+    args.ownerEmail,
+    mediaVerificationStateKey(args.recordingId),
+  ).catch(() => null);
+  const marker = parseMediaVerificationMarker(value);
+  return marker?.recordingId === args.recordingId;
+}

package/corpus/templates/clips/server/lib/player-thumbnail-url.ts

@@ -0,0 +1,31 @@
+export type PlayerThumbnailRecording = {
+  id: string;
+  thumbnailUrl?: string | null;
+  animatedThumbnailUrl?: string | null;
+};
+
+function appendQueryParam(url: string, key: string, value: string): string {
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+}
+
+export function localRecordingThumbnailRoute(recordingId: string): string {
+  return `/api/thumbnail/${encodeURIComponent(recordingId)}`;
+}
+
+export function resolvePlayerThumbnailUrl(
+  recording: PlayerThumbnailRecording,
+  options: {
+    accessToken?: string | null;
+    appPath?: (path: string) => string;
+  } = {},
+): string | null {
+  if (!recording.thumbnailUrl && !recording.animatedThumbnailUrl) return null;
+
+  let resolved = localRecordingThumbnailRoute(recording.id);
+  if (options.accessToken) {
+    resolved = appendQueryParam(resolved, "t", options.accessToken);
+  }
+  if (options.appPath) resolved = options.appPath(resolved);
+  return resolved;
+}

package/corpus/templates/clips/server/lib/post-finalize-dispatch.ts

@@ -7,7 +7,7 @@ import {
   signScopedAgentAccessToken,
 } from "@agent-native/core/server";
 
-export type PostFinalizeJobKind = "seekable" | "transcript";
+export type PostFinalizeJobKind = "media-ready" | "seekable" | "transcript";
 
 export const POST_FINALIZE_JOB_TOKEN_KIND = "clips-post-finalize-job";
 
@@ -47,10 +47,12 @@ export async function dispatchPostFinalizeJob(args: {
   delayMs?: number;
   retryAttempt?: number;
   regenerate?: boolean;
+  requireAccepted?: boolean;
 }): Promise<void> {
+  const { requireAccepted = false, ...job } = args;
   const token = signScopedAgentAccessToken({
     resourceKind: POST_FINALIZE_JOB_TOKEN_KIND,
-    resourceId: postFinalizeJobResourceId(args.recordingId, args.kind),
+    resourceId: postFinalizeJobResourceId(job.recordingId, job.kind),
     ttlSeconds: 10 * 60,
   });
   const basePath = normalizeBasePath(
@@ -62,7 +64,7 @@ export async function dispatchPostFinalizeJob(args: {
   const usesDurableBackground =
     dispatchPathTargetsNetlifyBackgroundFunction(dispatchPath);
   const body = JSON.stringify({
-    ...args,
+    ...job,
     token,
     ...(usesDurableBackground
       ? {
@@ -100,6 +102,11 @@ export async function dispatchPostFinalizeJob(args: {
     });
   });
 
+  if (requireAccepted) {
+    await dispatch;
+    return;
+  }
+
   await Promise.race([
     dispatch,
     new Promise<void>((resolve) => setTimeout(resolve, DISPATCH_SETTLE_MS)),

package/corpus/templates/clips/server/plugins/auth.ts

@@ -37,12 +37,12 @@ export default createAuthPlugin({
     "/api/media",
     "/api/clips-latest.json",
     "/api/clips-updater.json",
-    // Blob-serving for the dev-fallback (no provider) path.
-    // The route itself enforces resolveAccess + password/expiry checks;
-    // we add it to publicPaths so anonymous viewers on /share/:id can
-    // actually fetch the <video> bytes for public recordings. The chunk
-    // upload POSTs stay behind auth under /api/uploads/*.
+    // Public media-serving routes enforce resolveAccess + password/expiry
+    // checks themselves. They need to bypass the app auth shell so anonymous
+    // viewers and crawlers can fetch public share media. Chunk upload POSTs
+    // stay behind auth under /api/uploads/*.
     "/api/video",
+    "/api/thumbnail",
     "/api/auth/google-calendar",
     "/_agent-native/google/auth-url",
     "/_agent-native/google/callback",

package/corpus/templates/clips/server/plugins/calendar-jobs.ts

@@ -6,6 +6,7 @@
  */
 
 import registerBuilderMediaCompressionJob from "../jobs/builder-media-compression.js";
+import registerMediaVerificationJob from "../jobs/media-verification.js";
 import registerMeetingRemindersJob from "../jobs/meeting-reminders.js";
 import registerPollCalendarsJob from "../jobs/poll-calendars.js";
 import registerStaleMeetingSweeperJob from "../jobs/stale-meeting-sweeper.js";
@@ -16,6 +17,7 @@ export default () => {
   // background loop is off.
   registerMeetingRemindersJob();
   registerBuilderMediaCompressionJob();
+  registerMediaVerificationJob();
   registerPollCalendarsJob();
   registerStaleMeetingSweeperJob();
 };

package/corpus/templates/clips/server/routes/api/_agent-native-background/post-finalize-worker.post.ts

@@ -11,6 +11,7 @@ import {
 } from "h3";
 import { z } from "zod";
 
+import finalizeRecording from "../../../../actions/finalize-recording.js";
 import { ensureRecordingSeekable } from "../../../../actions/lib/ensure-seekable-video.js";
 import requestTranscript from "../../../../actions/request-transcript.js";
 import { getDb, schema } from "../../../db/index.js";
@@ -22,7 +23,7 @@ import {
 
 const bodySchema = z.object({
   recordingId: z.string().min(1).max(200),
-  kind: z.enum(["seekable", "transcript"]),
+  kind: z.enum(["media-ready", "seekable", "transcript"]),
   token: z.string().min(1),
   delayMs: z.number().int().min(0).max(30_000).optional(),
   retryAttempt: z.number().int().min(1).max(10).optional(),
@@ -61,7 +62,8 @@ export default defineEventHandler(async (event: H3Event) => {
     setResponseStatus(event, 404);
     return { ok: false, error: "Recording not found" };
   }
-  if (recording.status !== "ready") {
+  const requiredStatus = kind === "media-ready" ? "processing" : "ready";
+  if (recording.status !== requiredStatus) {
     return {
       ok: true,
       recordingId,
@@ -84,6 +86,7 @@ export default defineEventHandler(async (event: H3Event) => {
           kind,
           retryAttempt,
           regenerate,
+          requireAccepted: kind === "media-ready",
         });
         return {
           ok: true,
@@ -100,6 +103,13 @@ export default defineEventHandler(async (event: H3Event) => {
         });
         return { ok: true, kind, result };
       }
+      if (kind === "media-ready") {
+        const result = await finalizeRecording.run({
+          id: recordingId,
+          mediaVerificationRetryAttempt: retryAttempt ?? 1,
+        });
+        return { ok: true, kind, result };
+      }
 
       const result = await requestTranscript.run({
         recordingId,

package/corpus/templates/clips/server/routes/api/public-recording.get.ts

@@ -42,6 +42,8 @@ import {
 } from "../../../shared/transcript-segments.js";
 import { resolveTranscriptPresentation } from "../../../shared/transcript-status.js";
 import { getDb, schema } from "../../db/index.js";
+import { isMediaVerificationPending } from "../../lib/media-verification-state.js";
+import { resolvePlayerThumbnailUrl } from "../../lib/player-thumbnail-url.js";
 import { resolvePlayerVideoUrl } from "../../lib/player-video-url.js";
 import {
   getOrganizationRoleForEmail,
@@ -367,6 +369,10 @@ export default defineEventHandler(async (event) => {
     resolvedVideoUrl,
     protectedMediaToken,
   );
+  const playbackThumbnailUrl = resolvePlayerThumbnailUrl(rec, {
+    accessToken: protectedMediaToken,
+    appPath,
+  });
 
   const canExposeAgentContext =
     (rec.visibility === "public" || tokenAllowsAgentAccess || viewerIsOwner) &&
@@ -393,13 +399,18 @@ export default defineEventHandler(async (event) => {
   // Referer of any outbound link the share page renders.
   setResponseHeader(event, "Referrer-Policy", "no-referrer");
   const transcriptPresentation = resolveTranscriptPresentation(transcript);
+  const verificationPending = await isMediaVerificationPending({
+    ownerEmail: rec.ownerEmail,
+    recordingId,
+    recordingStatus: rec.status,
+  });
 
   return {
     recording: {
       id: rec.id,
       title: rec.title,
       description: rec.description,
-      thumbnailUrl: rec.thumbnailUrl,
+      thumbnailUrl: playbackThumbnailUrl,
       animatedThumbnailUrl: rec.animatedThumbnailUrl,
       sourceAppName: rec.sourceAppName,
       durationMs: rec.durationMs,
@@ -411,6 +422,7 @@ export default defineEventHandler(async (event) => {
       hasAudio: Boolean(rec.hasAudio),
       hasCamera: Boolean(rec.hasCamera),
       status: rec.status,
+      verificationPending,
       uploadProgress: rec.uploadProgress,
       failureReason: rec.failureReason,
       // Don't leak the password to clients; just indicate whether one was set.