@agent-native/core 0.122.0 → 0.122.2

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 }) => {

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/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/routes/_app.library._index.tsx

@@ -6,7 +6,7 @@ import { LibraryGrid } from "@/components/library/library-grid";
 import { usePageHeaderLayout } from "@/components/library/page-header";
 import { Button } from "@/components/ui/button";
 
-const SEO_TITLE = "Agent-Native Clips - Open Source screen recorder";
+const SEO_TITLE = "Clips - Open Source screen recorder";
 const SEO_DESCRIPTION =
   "Open Source screen recorder and meeting-notes app with AI transcripts, summaries, search, dictation, and agent-readable share links.";
 

package/corpus/templates/clips/app/routes/_index.tsx

@@ -1,7 +1,7 @@
 import { DefaultSpinner } from "@agent-native/core/client/ui";
 import { redirect, type LoaderFunctionArgs } from "react-router";
 
-const SEO_TITLE = "Agent-Native Clips - Open Source screen recorder";
+const SEO_TITLE = "Clips - Open Source screen recorder";
 const SEO_DESCRIPTION =
   "Open Source screen recorder and meeting-notes app with AI transcripts, summaries, search, dictation, and agent-readable share links.";
 

package/corpus/templates/clips/app/routes/r.$recordingId.tsx

@@ -596,6 +596,12 @@ export default function RecordingPage() {
         });
         return;
       }
+      if (retryingLoomImport && result?.status === "processing") {
+        // Download + reupload now run as a background job; this request only
+        // confirms the retry was accepted, not that the clip is ready yet.
+        toast.info(t("recordingPage.importingLoom"));
+        return;
+      }
       toast.success(
         retryingLoomImport
           ? t("recordingPage.loomImportResumed")

package/corpus/templates/clips/app/routes/record.tsx

@@ -1850,6 +1850,11 @@ export default function RecordRoute() {
             description: t("recordRoute.connectStorageToRetryLoom"),
             duration: 12_000,
           });
+        } else if (result?.status === "processing") {
+          // The video download + reupload run as a background job (see
+          // import-loom-recording.ts) so this request stays fast regardless of
+          // Loom video length; the recording page polls until it is ready.
+          toast.info(t("recordingPage.importingLoom"));
         } else {
           showSavedToast(
             t("recordRoute.loomImported"),

package/corpus/templates/clips/changelog/2026-07-25-app-branding-now-uses-the-product-name-without-the-agent-nat.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-25
+---
+
+App branding now uses the product name without the Agent-Native prefix.

package/corpus/templates/clips/changelog/2026-07-25-settings-navigation-now-keeps-manage-agent-as-a-dedicated-li.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-25
+---
+
+Settings navigation now keeps Manage agent as a dedicated linked destination at the bottom.

package/corpus/templates/clips/server/db/schema.ts

@@ -166,6 +166,8 @@ export const recordings = table("recordings", {
     .default("uploading"),
   uploadProgress: integer("upload_progress").notNull().default(0),
   failureReason: text("failure_reason"),
+  loomImportClaimId: text("loom_import_claim_id"),
+  loomImportClaimedAt: text("loom_import_claimed_at"),
 
   // Non-destructive edits: JSON `{ trims: [{startMs,endMs,excluded}], blurs: [...], speed: [...] }`
   editsJson: text("edits_json").notNull().default("{}"),

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

@@ -11,7 +11,8 @@ export type PostFinalizeJobKind =
   | "media-ready"
   | "seekable"
   | "transcript"
-  | "brain-export";
+  | "brain-export"
+  | "loom-import";
 
 export const POST_FINALIZE_JOB_TOKEN_KIND = "clips-post-finalize-job";
 

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

@@ -7,7 +7,7 @@ export default createAuthPlugin({
   // callback can handle both normal sign-in and the Calendar connect flow.
   mountGoogleOAuthRoutes: false,
   marketing: {
-    appName: "Agent-Native Clips",
+    appName: "Clips",
     tagline:
       "Your AI agent transcribes, summarizes, and searches everything you record alongside you.",
     features: [

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

@@ -873,6 +873,14 @@ const migrations = runMigrations(
         `CREATE INDEX IF NOT EXISTS recording_agent_views_recording_idx ON recording_agent_views (recording_id, last_seen_at)`,
       ].join("; "),
     },
+    {
+      version: 52,
+      name: "recording-loom-import-claim-lease",
+      sql: [
+        `ALTER TABLE recordings ADD COLUMN IF NOT EXISTS loom_import_claim_id TEXT`,
+        `ALTER TABLE recordings ADD COLUMN IF NOT EXISTS loom_import_claimed_at TEXT`,
+      ].join("; "),
+    },
   ],
   { table: "clips_migrations" },
 );