@agent-native/core 0.87.0 → 0.90.1

package/corpus/templates/clips/actions/split-recording.ts

@@ -11,7 +11,8 @@
 
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { and, eq } from "drizzle-orm";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import {
@@ -20,12 +21,10 @@ import {
   serializeEdits,
 } from "../app/lib/timestamp-mapping.js";
 import { getDb, schema } from "../server/db/index.js";
-import {
-  getCurrentOwnerEmail,
-  ownerEmailMatches,
-} from "../server/lib/recordings.js";
 import { assertNativeRecordingMedia } from "./lib/native-media.js";
 
+const MAX_CAS_ATTEMPTS = 5;
+
 export default defineAction({
   description:
     "Add a split marker at the given timestamp. A split is a UI-only marker — it does not change playback. Used to operate on segments independently.",
@@ -38,42 +37,57 @@ export default defineAction({
       .describe("Split point in milliseconds (original time)"),
   }),
   run: async (args) => {
+    await assertAccess("recording", args.recordingId, "editor");
+
     const db = getDb();
-    const ownerEmail = getCurrentOwnerEmail();
 
-    const [existing] = await db
-      .select()
-      .from(schema.recordings)
-      .where(
-        and(
-          eq(schema.recordings.id, args.recordingId),
-          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
-        ),
-      );
-    if (!existing) {
-      throw new Error(`Recording not found: ${args.recordingId}`);
-    }
-    assertNativeRecordingMedia(existing);
+    let next: ReturnType<typeof appendSplit> | undefined;
 
-    const edits = parseEdits(existing.editsJson);
-    const next = appendSplit(edits, args.atMs);
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const [existing] = await db
+        .select()
+        .from(schema.recordings)
+        .where(eq(schema.recordings.id, args.recordingId));
+      if (!existing) {
+        throw new Error(`Recording not found: ${args.recordingId}`);
+      }
+      assertNativeRecordingMedia(existing);
 
-    await db
-      .update(schema.recordings)
-      .set({
-        editsJson: serializeEdits(next),
-        updatedAt: new Date().toISOString(),
-      })
-      .where(eq(schema.recordings.id, args.recordingId));
+      const previousEditsJson = existing.editsJson;
+      const edits = parseEdits(previousEditsJson);
+      next = appendSplit(edits, args.atMs);
 
-    await writeAppState("refresh-signal", { ts: Date.now() });
+      const result = await db
+        .update(schema.recordings)
+        .set({
+          editsJson: serializeEdits(next),
+          updatedAt: new Date().toISOString(),
+        })
+        .where(
+          and(
+            eq(schema.recordings.id, args.recordingId),
+            previousEditsJson == null
+              ? isNull(schema.recordings.editsJson)
+              : eq(schema.recordings.editsJson, previousEditsJson),
+          ),
+        )
+        .returning({ id: schema.recordings.id });
 
-    console.log(`Split ${args.recordingId} at ${args.atMs} ms`);
+      if (result.length > 0) {
+        await writeAppState("refresh-signal", { ts: Date.now() });
+        console.log(`Split ${args.recordingId} at ${args.atMs} ms`);
+        return {
+          id: args.recordingId,
+          atMs: args.atMs,
+          editsJson: next,
+        };
+      }
+      // Someone else changed editsJson between our read and write — retry
+      // against the now-current value.
+    }
 
-    return {
-      id: args.recordingId,
-      atMs: args.atMs,
-      editsJson: next,
-    };
+    throw new Error(
+      `Could not split recording ${args.recordingId} after ${MAX_CAS_ATTEMPTS} concurrent attempts.`,
+    );
   },
 });

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

@@ -29,7 +29,7 @@
 
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { and, eq, inArray } from "drizzle-orm";
+import { and, inArray } from "drizzle-orm";
 import { z } from "zod";
 
 import { parseEdits, serializeEdits } from "../app/lib/timestamp-mapping.js";
@@ -92,7 +92,10 @@ export default defineAction({
       throw new Error("stitch-recordings needs at least 2 sourceRecordingIds");
     }
 
-    // Load sources so we can copy workspace + validate ownership.
+    // Stitch creates a brand-new recording owned by the caller that defaults
+    // to public visibility, so every source must be OWNED by the caller (not
+    // just editor-shared) — otherwise a user with editor access to a
+    // private/org clip could reshare it as a new public recording they own.
     const sources = await db
       .select()
       .from(schema.recordings)
@@ -104,7 +107,7 @@ export default defineAction({
       );
     if (sources.length !== ids.length) {
       throw new Error(
-        `Not all source recordings were found (or not owned): asked for ${ids.length}, got ${sources.length}`,
+        `Not all source recordings were found: asked for ${ids.length}, got ${sources.length}`,
       );
     }
 
@@ -130,7 +133,7 @@ export default defineAction({
 
     // Seed editsJson with provenance so the editor/player can link back.
     const edits = parseEdits("{}");
-    (edits as any).stitchedFrom = ids;
+    edits.stitchedFrom = ids;
 
     await db.insert(schema.recordings).values({
       id,

package/corpus/templates/clips/actions/stop-meeting-recording.ts

@@ -34,12 +34,26 @@ export default defineAction({
       .limit(1);
     if (!meeting) throw new Error(`Meeting not found: ${args.meetingId}`);
 
+    // Only mark the transcript "ready" if a transcript actually exists —
+    // otherwise finalize-meeting has nothing to summarize and there would be
+    // no way for the UI to distinguish "notes coming" from "nothing was ever
+    // captured". Match finalize-meeting's own empty-transcript handling.
+    let hasTranscript = false;
+    if (meeting.recordingId) {
+      const [transcript] = await db
+        .select({ fullText: schema.recordingTranscripts.fullText })
+        .from(schema.recordingTranscripts)
+        .where(eq(schema.recordingTranscripts.recordingId, meeting.recordingId))
+        .limit(1);
+      hasTranscript = Boolean(transcript?.fullText?.trim());
+    }
+
     await db
       .update(schema.meetings)
       .set({
         actualEnd: meeting.actualEnd ?? nowIso,
         updatedAt: nowIso,
-        transcriptStatus: "ready",
+        transcriptStatus: hasTranscript ? "ready" : "failed",
       })
       .where(eq(schema.meetings.id, args.meetingId));
 

package/corpus/templates/clips/actions/sync-calendars.ts

@@ -17,110 +17,21 @@ import { randomUUID } from "node:crypto";
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { emit } from "@agent-native/core/event-bus";
-import { readAppSecret, writeAppSecret } from "@agent-native/core/secrets";
 import { accessFilter } from "@agent-native/core/sharing";
 import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import {
+  resolveCalendarAccessToken,
+  shouldMarkNeedsReauth,
+} from "../server/lib/calendar-event-meetings.js";
 import {
   listEvents,
-  resolveGoogleOAuthCredentialCandidates,
-  refreshAccessTokenWithFallback,
   pickJoinUrl,
   type CalendarEvent,
 } from "../server/lib/google-calendar-client.js";
 
-interface AccessTokenBundle {
-  accessToken: string;
-  expiresAt?: number;
-  tokenType?: string;
-  scope?: string;
-}
-
-function parseAccessBundle(raw: string): AccessTokenBundle {
-  try {
-    const parsed = JSON.parse(raw) as AccessTokenBundle;
-    if (parsed && typeof parsed.accessToken === "string") return parsed;
-  } catch {
-    // older shape: raw token string
-  }
-  return { accessToken: raw };
-}
-
-/**
- * Resolve a fresh access token, refreshing via Google if expired.
- * Returns null if the account is unrecoverable (no refresh token,
- * permanent refresh failure).
- */
-async function resolveAccessToken(args: {
-  ownerEmail: string;
-  accessRef: string | null;
-  refreshRef: string | null;
-}): Promise<string | null> {
-  const credentialCandidates = resolveGoogleOAuthCredentialCandidates();
-  if (!credentialCandidates.length) return null;
-
-  let bundle: AccessTokenBundle | null = null;
-  if (args.accessRef) {
-    const stored = await readAppSecret({
-      key: args.accessRef,
-      scope: "user",
-      scopeId: args.ownerEmail,
-    });
-    if (stored?.value) bundle = parseAccessBundle(stored.value);
-  }
-
-  // Token is fresh enough → use as-is (5 min skew).
-  if (
-    bundle?.accessToken &&
-    bundle.expiresAt &&
-    Date.now() < bundle.expiresAt - 5 * 60 * 1000
-  ) {
-    return bundle.accessToken;
-  }
-  if (bundle?.accessToken && !bundle.expiresAt) {
-    // Unknown expiry — try once and let the caller retry on 401 if needed.
-    return bundle.accessToken;
-  }
-
-  // Refresh path.
-  if (!args.refreshRef) return null;
-  const refreshSecret = await readAppSecret({
-    key: args.refreshRef,
-    scope: "user",
-    scopeId: args.ownerEmail,
-  });
-  if (!refreshSecret?.value) return null;
-
-  let refreshed;
-  try {
-    refreshed = await refreshAccessTokenWithFallback({
-      refreshToken: refreshSecret.value,
-      credentials: credentialCandidates,
-    });
-  } catch {
-    return null;
-  }
-  if (!refreshed.access_token) return null;
-  if (args.accessRef) {
-    await writeAppSecret({
-      key: args.accessRef,
-      value: JSON.stringify({
-        accessToken: refreshed.access_token,
-        expiresAt: refreshed.expires_in
-          ? Date.now() + refreshed.expires_in * 1000
-          : undefined,
-        tokenType: refreshed.token_type,
-        scope: refreshed.scope,
-      }),
-      scope: "user",
-      scopeId: args.ownerEmail,
-    });
-  }
-  return refreshed.access_token;
-}
-
 function eventStartIso(event: CalendarEvent): string | null {
   return event.start?.dateTime || event.start?.date || null;
 }
@@ -129,16 +40,6 @@ function eventEndIso(event: CalendarEvent): string | null {
   return event.end?.dateTime || event.end?.date || null;
 }
 
-function shouldMarkNeedsReauth(message: string): boolean {
-  const lower = message.toLowerCase();
-  return (
-    lower.includes("google calendar list failed (401)") ||
-    lower.includes("invalid_grant") ||
-    lower.includes("invalid_token") ||
-    lower.includes("insufficient_scope")
-  );
-}
-
 export default defineAction({
   description:
     "Refresh connected calendar event snapshots for compatibility. The Meetings UI reads Google Calendar live and does not require this action.",
@@ -190,11 +91,12 @@ export default defineAction({
       let perAccountEvents = 0;
       let perAccountMeetings = 0;
       try {
-        const accessToken = await resolveAccessToken({
-          ownerEmail: account.ownerEmail,
-          accessRef: account.accessTokenSecretRef ?? null,
-          refreshRef: account.refreshTokenSecretRef ?? null,
-        });
+        // A permanent refresh failure (dead token / bad client) resolves to
+        // `null` here (handled below as needs-reauth). A transient failure
+        // (network error, 429, 5xx) is rethrown by resolveCalendarAccessToken
+        // and caught by this try's own catch, which records it as a soft
+        // sync error via shouldMarkNeedsReauth without flipping status.
+        const accessToken = await resolveCalendarAccessToken(account);
         if (!accessToken) {
           // Fix 10: isolate this account's needs-reauth write in its own
           // try/catch so a downstream throw on a different account doesn't

package/corpus/templates/clips/actions/trash-recording.ts

@@ -7,44 +7,73 @@
 
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { and, eq } from "drizzle-orm";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, ne } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import {
-  getCurrentOwnerEmail,
-  ownerEmailMatches,
-} from "../server/lib/recordings.js";
 
 export default defineAction({
   description:
     "Move a recording to trash. Soft-delete — use restore-recording to undo, or delete-recording-permanent to remove forever.",
   schema: z.object({
     id: z.string().describe("Recording ID"),
+    skipIfReady: z
+      .boolean()
+      .optional()
+      .describe(
+        "When true, don't trash a recording whose upload already finished (status is 'ready') — used to close a cancel-vs-finalize race atomically.",
+      ),
   }),
   run: async (args) => {
+    await assertAccess("recording", args.id, "editor");
+
     const db = getDb();
-    const ownerEmail = getCurrentOwnerEmail();
 
     const [existing] = await db
       .select({ id: schema.recordings.id })
       .from(schema.recordings)
-      .where(
-        and(
-          eq(schema.recordings.id, args.id),
-          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
-        ),
-      );
+      .where(eq(schema.recordings.id, args.id));
     if (!existing) throw new Error(`Recording not found: ${args.id}`);
 
     const now = new Date().toISOString();
+    // When `skipIfReady` is set, make the trash conditional on the row NOT
+    // already being 'ready' — this closes the TOCTOU race where finalize
+    // flips the row to 'ready' concurrently with a cancel. Without the WHERE
+    // guard, a finalize that lands between a caller's read and this write
+    // would get silently trashed even though the upload finished.
     await db
       .update(schema.recordings)
       .set({ trashedAt: now, updatedAt: now })
+      .where(
+        args.skipIfReady
+          ? and(
+              eq(schema.recordings.id, args.id),
+              ne(schema.recordings.status, "ready"),
+            )
+          : eq(schema.recordings.id, args.id),
+      );
+
+    // Re-select to report whether the trash actually applied — portable
+    // across Postgres/SQLite without relying on driver-specific affected-row
+    // counts.
+    const [after] = await db
+      .select({
+        status: schema.recordings.status,
+        trashedAt: schema.recordings.trashedAt,
+      })
+      .from(schema.recordings)
       .where(eq(schema.recordings.id, args.id));
 
+    const trashedAt = after?.trashedAt ?? null;
+    const skipped = Boolean(args.skipIfReady) && !trashedAt;
+
     await writeAppState("refresh-signal", { ts: Date.now() });
-    console.log(`Trashed recording ${args.id}`);
-    return { id: args.id, trashedAt: now };
+    console.log(
+      skipped
+        ? `Skipped trashing recording ${args.id} — already ready`
+        : `Trashed recording ${args.id}`,
+    );
+    return { id: args.id, trashedAt, skipped };
   },
 });

package/corpus/templates/clips/actions/trim-recording.ts

@@ -12,7 +12,7 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import {
@@ -23,6 +23,8 @@ import {
 import { getDb, schema } from "../server/db/index.js";
 import { assertNativeRecordingMedia } from "./lib/native-media.js";
 
+const MAX_CAS_ATTEMPTS = 5;
+
 export default defineAction({
   description:
     "Append a trim range to a recording. The range is excluded from playback but the source video is never modified. Adjacent/overlapping ranges are merged.",
@@ -48,36 +50,55 @@ export default defineAction({
 
     const db = getDb();
 
-    const [existing] = await db
-      .select()
-      .from(schema.recordings)
-      .where(eq(schema.recordings.id, args.recordingId));
-    if (!existing) {
-      throw new Error(`Recording not found: ${args.recordingId}`);
-    }
-    assertNativeRecordingMedia(existing);
+    let next: ReturnType<typeof mergeExcluded> | undefined;
 
-    const edits = parseEdits(existing.editsJson);
-    const next = mergeExcluded(edits, args.startMs, args.endMs);
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const [existing] = await db
+        .select()
+        .from(schema.recordings)
+        .where(eq(schema.recordings.id, args.recordingId));
+      if (!existing) {
+        throw new Error(`Recording not found: ${args.recordingId}`);
+      }
+      assertNativeRecordingMedia(existing);
 
-    await db
-      .update(schema.recordings)
-      .set({
-        editsJson: serializeEdits(next),
-        updatedAt: new Date().toISOString(),
-      })
-      .where(eq(schema.recordings.id, args.recordingId));
+      const previousEditsJson = existing.editsJson;
+      const edits = parseEdits(previousEditsJson);
+      next = mergeExcluded(edits, args.startMs, args.endMs);
 
-    await writeAppState("refresh-signal", { ts: Date.now() });
+      const result = await db
+        .update(schema.recordings)
+        .set({
+          editsJson: serializeEdits(next),
+          updatedAt: new Date().toISOString(),
+        })
+        .where(
+          and(
+            eq(schema.recordings.id, args.recordingId),
+            previousEditsJson == null
+              ? isNull(schema.recordings.editsJson)
+              : eq(schema.recordings.editsJson, previousEditsJson),
+          ),
+        )
+        .returning({ id: schema.recordings.id });
 
-    console.log(
-      `Trimmed ${args.recordingId}: ${args.startMs}–${args.endMs} ms (now ${next.trims.filter((t) => t.excluded).length} excluded ranges)`,
-    );
+      if (result.length > 0) {
+        await writeAppState("refresh-signal", { ts: Date.now() });
+        console.log(
+          `Trimmed ${args.recordingId}: ${args.startMs}–${args.endMs} ms (now ${next.trims.filter((t) => t.excluded).length} excluded ranges)`,
+        );
+        return {
+          id: args.recordingId,
+          editsJson: next,
+          trimCount: next.trims.filter((t) => t.excluded).length,
+        };
+      }
+      // Someone else changed editsJson between our read and write — retry
+      // against the now-current value.
+    }
 
-    return {
-      id: args.recordingId,
-      editsJson: next,
-      trimCount: next.trims.filter((t) => t.excluded).length,
-    };
+    throw new Error(
+      `Could not trim recording ${args.recordingId} after ${MAX_CAS_ATTEMPTS} concurrent attempts.`,
+    );
   },
 });

package/corpus/templates/clips/actions/undo-edit.ts

@@ -10,7 +10,8 @@
 
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { and, eq } from "drizzle-orm";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import {
@@ -19,12 +20,10 @@ import {
   serializeEdits,
 } from "../app/lib/timestamp-mapping.js";
 import { getDb, schema } from "../server/db/index.js";
-import {
-  getCurrentOwnerEmail,
-  ownerEmailMatches,
-} from "../server/lib/recordings.js";
 import { assertNativeRecordingMedia } from "./lib/native-media.js";
 
+const MAX_CAS_ATTEMPTS = 5;
+
 export default defineAction({
   description:
     "Undo the last trim on a recording by removing the most-recently-added excluded range. No redo.",
@@ -32,45 +31,58 @@ export default defineAction({
     recordingId: z.string().describe("Recording ID"),
   }),
   run: async (args) => {
+    await assertAccess("recording", args.recordingId, "editor");
+
     const db = getDb();
-    const ownerEmail = getCurrentOwnerEmail();
 
-    const [existing] = await db
-      .select()
-      .from(schema.recordings)
-      .where(
-        and(
-          eq(schema.recordings.id, args.recordingId),
-          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
-        ),
-      );
-    if (!existing) {
-      throw new Error(`Recording not found: ${args.recordingId}`);
-    }
-    assertNativeRecordingMedia(existing);
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const [existing] = await db
+        .select()
+        .from(schema.recordings)
+        .where(eq(schema.recordings.id, args.recordingId));
+      if (!existing) {
+        throw new Error(`Recording not found: ${args.recordingId}`);
+      }
+      assertNativeRecordingMedia(existing);
 
-    const before = parseEdits(existing.editsJson);
-    const after = popLastExcluded(before);
+      const previousEditsJson = existing.editsJson;
+      const before = parseEdits(previousEditsJson);
+      const after = popLastExcluded(before);
 
-    if (before.trims.length === after.trims.length) {
-      console.log(`No trim to undo on ${args.recordingId}`);
-      return { id: args.recordingId, undone: false, editsJson: after };
-    }
+      if (before.trims.length === after.trims.length) {
+        console.log(`No trim to undo on ${args.recordingId}`);
+        return { id: args.recordingId, undone: false, editsJson: after };
+      }
 
-    await db
-      .update(schema.recordings)
-      .set({
-        editsJson: serializeEdits(after),
-        updatedAt: new Date().toISOString(),
-      })
-      .where(eq(schema.recordings.id, args.recordingId));
+      const result = await db
+        .update(schema.recordings)
+        .set({
+          editsJson: serializeEdits(after),
+          updatedAt: new Date().toISOString(),
+        })
+        .where(
+          and(
+            eq(schema.recordings.id, args.recordingId),
+            previousEditsJson == null
+              ? isNull(schema.recordings.editsJson)
+              : eq(schema.recordings.editsJson, previousEditsJson),
+          ),
+        )
+        .returning({ id: schema.recordings.id });
 
-    await writeAppState("refresh-signal", { ts: Date.now() });
+      if (result.length > 0) {
+        await writeAppState("refresh-signal", { ts: Date.now() });
+        console.log(
+          `Undid last trim on ${args.recordingId} (now ${after.trims.filter((t) => t.excluded).length} excluded ranges)`,
+        );
+        return { id: args.recordingId, undone: true, editsJson: after };
+      }
+      // Someone else changed editsJson between our read and write — retry
+      // against the now-current value.
+    }
 
-    console.log(
-      `Undid last trim on ${args.recordingId} (now ${after.trims.filter((t) => t.excluded).length} excluded ranges)`,
+    throw new Error(
+      `Could not undo edit on recording ${args.recordingId} after ${MAX_CAS_ATTEMPTS} concurrent attempts.`,
     );
-
-    return { id: args.recordingId, undone: true, editsJson: after };
   },
 });

package/corpus/templates/clips/app/components/capture-install-options.tsx

@@ -1,10 +1,4 @@
 import { appPath, useT } from "@agent-native/core/client";
-import { Button, type ButtonProps } from "@agent-native/toolkit/ui/button";
-import {
-  Popover,
-  PopoverContent,
-  PopoverTrigger,
-} from "@agent-native/toolkit/ui/popover";
 import {
   IconBrandApple,
   IconBrandChrome,
@@ -15,6 +9,12 @@ import {
 } from "@tabler/icons-react";
 import { type ReactNode } from "react";
 
+import { Button, type ButtonProps } from "@/components/ui/button";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@/components/ui/popover";
 import {
   clipsChromeExtensionEnabled,
   clipsChromeExtensionUrl,