@agent-native/core 0.134.0 → 0.135.0

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/resume.get.ts

@@ -11,17 +11,25 @@
  * Route: GET /api/uploads/:recordingId/resume
  */
 
+import {
+  compareAndSetAppState,
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
+import { isFeatureFlagEnabled } from "@agent-native/core/feature-flags";
 import { runWithRequestContext } from "@agent-native/core/server";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import {
   createError,
   defineEventHandler,
   getRouterParam,
+  getQuery,
   setResponseHeader,
   setResponseStatus,
   type H3Event,
 } from "h3";
 
+import { UPLOAD_RETRY_RESUME_FLAG } from "../../../../../shared/feature-flags.js";
 import { getDb, schema } from "../../../../db/index.js";
 import {
   listRecordingChunkKeys,
@@ -33,7 +41,11 @@ import {
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
 import { getResumableSession } from "../../../../lib/resumable-session.js";
-import { renewUploadLease } from "../../../../lib/upload-lease.js";
+import {
+  isRetryableUploadInterruption,
+  RETRYABLE_UPLOAD_INTERRUPTION_REASON,
+} from "../../../../lib/upload-interruption.js";
+import { uploadLeaseExpiry } from "../../../../lib/upload-lease.js";
 
 export default defineEventHandler(async (event: H3Event) => {
   setResponseHeader(event, "Cache-Control", "private, max-age=0, no-store");
@@ -41,6 +53,21 @@ export default defineEventHandler(async (event: H3Event) => {
   if (!recordingId) {
     throw createError({ statusCode: 400, message: "Missing recordingId" });
   }
+  const requestedAttemptIdValue = getQuery(event).attemptId;
+  const requestedAttemptId = Array.isArray(requestedAttemptIdValue)
+    ? requestedAttemptIdValue[0]
+    : requestedAttemptIdValue;
+  if (
+    typeof requestedAttemptId !== "string" ||
+    requestedAttemptId.length < 16 ||
+    requestedAttemptId.length > 128 ||
+    !/^[A-Za-z0-9_-]+$/.test(requestedAttemptId)
+  ) {
+    throw createError({
+      statusCode: 400,
+      message: "A valid upload retry attemptId is required",
+    });
+  }
 
   let ownerEmail: string;
   let orgId: string | undefined;
@@ -52,6 +79,21 @@ export default defineEventHandler(async (event: H3Event) => {
     throw createError({ statusCode: 401, message: "Unauthorized" });
   }
 
+  const recoveryEnabled = await isFeatureFlagEnabled(UPLOAD_RETRY_RESUME_FLAG, {
+    userEmail: ownerEmail,
+    userKey: ownerEmail,
+    orgId,
+  });
+  if (!recoveryEnabled) {
+    return {
+      recoveryEnabled: false,
+      resumable: false,
+      recordingId,
+      status: null,
+      reason: "feature_disabled",
+    };
+  }
+
   return runWithRequestContext({ userEmail: ownerEmail, orgId }, async () => {
     const [recording] = await getDb()
       .select({
@@ -59,6 +101,9 @@ export default defineEventHandler(async (event: H3Event) => {
         status: schema.recordings.status,
         failureReason: schema.recordings.failureReason,
         videoUrl: schema.recordings.videoUrl,
+        uploadProgress: schema.recordings.uploadProgress,
+        uploadAttemptId: schema.recordings.uploadAttemptId,
+        uploadGenerationId: schema.recordings.uploadGenerationId,
       })
       .from(schema.recordings)
       .where(
@@ -73,31 +118,160 @@ export default defineEventHandler(async (event: H3Event) => {
       return { error: "Recording not found" };
     }
 
-    const lease = await renewUploadLease(recordingId);
-    if (!lease.held) {
+    // Legacy rows keep their null generation and unscoped scratch. A reset
+    // upgrades them by installing a fresh generation before it deletes data.
+    const existingGenerationId = recording.uploadGenerationId ?? null;
+    const generationId = existingGenerationId;
+    const session = generationId
+      ? await getResumableSession(recordingId, generationId)
+      : await getResumableSession(recordingId);
+    const retryableFailure =
+      recording.status === "failed" &&
+      isRetryableUploadInterruption(recording.failureReason);
+    const existingAttemptId = recording.uploadAttemptId ?? null;
+    if (
+      recording.status === "uploading" &&
+      existingAttemptId !== null &&
+      existingAttemptId !== requestedAttemptId
+    ) {
+      setResponseStatus(event, 409);
+      return {
+        resumable: false,
+        recoveryEnabled: true,
+        recordingId,
+        status: "uploading",
+        reason: "retry_already_active",
+      };
+    }
+    if (recording.status !== "uploading" && !retryableFailure) {
+      return {
+        resumable: false,
+        recoveryEnabled: true,
+        recordingId,
+        status: recording.status,
+        failureReason: recording.failureReason,
+        videoUrl: recording.videoUrl,
+      };
+    }
+
+    const uploadStateKey = `recording-upload-${recordingId}`;
+    const uploadStateRaw = await readAppState(uploadStateKey);
+    const uploadState = uploadStateRaw ?? {};
+    const attemptId = requestedAttemptId;
+    const now = new Date().toISOString();
+    const claimed = await getDb()
+      .update(schema.recordings)
+      .set({
+        status: "uploading",
+        failureReason: null,
+        uploadAttemptId: attemptId,
+        ...(generationId ? { uploadGenerationId: generationId } : {}),
+        uploadLeaseExpiresAt: uploadLeaseExpiry(),
+        updatedAt: now,
+      })
+      .where(
+        and(
+          eq(schema.recordings.id, recordingId),
+          ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+          retryableFailure
+            ? eq(schema.recordings.status, "failed")
+            : eq(schema.recordings.status, "uploading"),
+          retryableFailure
+            ? eq(
+                schema.recordings.failureReason,
+                RETRYABLE_UPLOAD_INTERRUPTION_REASON,
+              )
+            : undefined,
+          existingAttemptId === null
+            ? isNull(schema.recordings.uploadAttemptId)
+            : eq(schema.recordings.uploadAttemptId, existingAttemptId),
+          existingGenerationId === null
+            ? isNull(schema.recordings.uploadGenerationId)
+            : eq(schema.recordings.uploadGenerationId, existingGenerationId),
+        ),
+      )
+      .returning({ id: schema.recordings.id });
+
+    if (claimed.length !== 1) {
+      setResponseStatus(event, 409);
       return {
         resumable: false,
+        recoveryEnabled: true,
         recordingId,
-        status: lease.status,
-        failureReason: lease.failureReason,
-        videoUrl: lease.videoUrl,
+        status: "uploading",
+        reason: "retry_already_active",
       };
     }
 
-    const session = await getResumableSession(recordingId).catch(() => null);
+    const uploadStateUpdated = await compareAndSetAppState(
+      uploadStateKey,
+      uploadStateRaw,
+      {
+        ...uploadState,
+        recordingId,
+        status: "uploading",
+        failureReason: null,
+        retryableInterruption: false,
+        progress: recording.uploadProgress,
+        uploadAttemptId: attemptId,
+        uploadGenerationId: generationId,
+        ...(session ? { bytesReceived: session.bytesUploaded } : {}),
+        updatedAt: now,
+      },
+    );
+    if (!uploadStateUpdated) {
+      const [current] = await getDb()
+        .select({
+          status: schema.recordings.status,
+          uploadAttemptId: schema.recordings.uploadAttemptId,
+          uploadGenerationId: schema.recordings.uploadGenerationId,
+        })
+        .from(schema.recordings)
+        .where(
+          and(
+            eq(schema.recordings.id, recordingId),
+            ownerEmailMatches(schema.recordings.ownerEmail, ownerEmail),
+          ),
+        );
+      if (
+        current?.status !== "uploading" ||
+        (current.uploadAttemptId ?? null) !== attemptId ||
+        (current.uploadGenerationId ?? null) !== generationId
+      ) {
+        setResponseStatus(event, 409);
+        return {
+          resumable: false,
+          recoveryEnabled: true,
+          recordingId,
+          status: current?.status ?? null,
+          reason: "upload_state_changed",
+        };
+      }
+      console.info(
+        `[upload-resume] upload state advanced under the same claim; preserving newer progress for ${recordingId}`,
+      );
+    }
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
     if (session) {
       return {
         resumable: true,
+        recoveryEnabled: true,
         recordingId,
-        status: recording.status,
+        status: "uploading",
         uploadMode: "streaming" as const,
+        attemptId,
+        ...(generationId ? { uploadGenerationId: generationId } : {}),
         bytesReceived: session.bytesUploaded,
         nextChunkIndex: (session.lastCommittedIndex ?? -1) + 1,
       };
     }
 
     const stored = new Set(
-      (await listRecordingChunkKeys(ownerEmail, recordingId))
+      (generationId
+        ? await listRecordingChunkKeys(ownerEmail, recordingId, generationId)
+        : await listRecordingChunkKeys(ownerEmail, recordingId)
+      )
         .map(recordingChunkIndexFromKey)
         .filter((index): index is number => index !== null),
     );
@@ -108,10 +282,15 @@ export default defineEventHandler(async (event: H3Event) => {
 
     return {
       resumable: true,
+      recoveryEnabled: true,
       recordingId,
-      status: recording.status,
+      status: "uploading",
       uploadMode: "buffered" as const,
-      bytesReceived: await sumRecordingChunkBytes(ownerEmail, recordingId),
+      attemptId,
+      ...(generationId ? { uploadGenerationId: generationId } : {}),
+      bytesReceived: generationId
+        ? await sumRecordingChunkBytes(ownerEmail, recordingId, generationId)
+        : await sumRecordingChunkBytes(ownerEmail, recordingId),
       nextChunkIndex,
     };
   });

package/corpus/templates/clips/shared/clips-ai-prefs.ts

@@ -27,10 +27,16 @@ export type ClipsAiPrefs = {
 
 export type ClipsUserPrefs = ClipsAiPrefs & {
   defaultPlaybackSpeed?: string;
+  /** Activity emails (comments, replies, reactions) only — never share invites. */
   emailNotifications?: boolean;
   transcriptCleanupEnabled?: boolean;
+  /** Overrides the organization default visibility for new recordings. */
+  defaultRecordingVisibility?: ClipsDefaultVisibility;
 };
 
+/** Visibility applied to new recordings unless the creator picks another. */
+export type ClipsDefaultVisibility = "private" | "org" | "public";
+
 export function isIncludeFullVideoInAiEnabled(
   prefs: ClipsAiPrefs | Record<string, unknown> | null | undefined,
 ): boolean {

package/corpus/templates/clips/shared/feature-flags.ts

@@ -28,7 +28,19 @@ export const CUSTOM_SCK_LIVE_UPLOAD_FLAG = defineFeatureFlag({
     "Upload recording chunks while capture is still in progress. Requires the custom ScreenCaptureKit pipeline.",
 });
 
+/**
+ * Desktop app and hosted upload routes: preserve interrupted resumable
+ * sessions and continue saved retries from the provider-confirmed offset.
+ */
+export const UPLOAD_RETRY_RESUME_FLAG = defineFeatureFlag({
+  key: "uploadRetryResume",
+  displayName: "Resumable upload retry",
+  description:
+    "Resume interrupted desktop uploads from their last confirmed byte instead of replaying the full local backup.",
+});
+
 export const CLIPS_FEATURE_FLAGS = defineFeatureFlags([
   USE_CUSTOM_SCK_PIPELINE_FLAG,
   CUSTOM_SCK_LIVE_UPLOAD_FLAG,
+  UPLOAD_RETRY_RESUME_FLAG,
 ]);

package/corpus/templates/clips/shared/recording-core.ts

@@ -76,6 +76,7 @@ export type ChunkUploadParams = {
   height?: number | null;
   hasAudio?: boolean;
   hasCamera?: boolean;
+  uploadGenerationId?: string;
 };
 
 export function normalizeChunkUploadNumber(value: unknown): number | undefined {
@@ -115,6 +116,9 @@ export function chunkUploadQuery(params: ChunkUploadParams): string {
   if (params.hasCamera !== undefined) {
     q.set("hasCamera", params.hasCamera ? "1" : "0");
   }
+  if (params.uploadGenerationId) {
+    q.set("uploadGenerationId", params.uploadGenerationId);
+  }
   return q.toString();
 }
 

package/corpus/templates/clips/vitest.config.ts

@@ -1,23 +1,27 @@
 import path from "node:path";
 
-import { defineConfig } from "vitest/config";
+import baseConfig from "@agent-native/core/vitest-config";
+import { defineConfig, mergeConfig } from "vitest/config";
 
-export default defineConfig({
-  resolve: {
-    alias: {
-      "@": path.resolve(__dirname, "./app"),
-      "@shared": path.resolve(__dirname, "./shared"),
+export default mergeConfig(
+  baseConfig,
+  defineConfig({
+    resolve: {
+      alias: {
+        "@": path.resolve(__dirname, "./app"),
+        "@shared": path.resolve(__dirname, "./shared"),
+      },
     },
-  },
-  test: {
-    include: ["**/*.{test,spec}.?(c|m)[jt]s?(x)"],
-    exclude: [
-      "**/node_modules/**",
-      "**/.git/**",
-      "**/dist/**",
-      "**/.output/**",
-      "**/.react-router/**",
-      "**/e2e/**",
-    ],
-  },
-});
+    test: {
+      include: ["**/*.{test,spec}.?(c|m)[jt]s?(x)"],
+      exclude: [
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/dist/**",
+        "**/.output/**",
+        "**/.react-router/**",
+        "**/e2e/**",
+      ],
+    },
+  }),
+);

package/corpus/templates/content/.agents/skills/document-editing/references/databases.md

@@ -132,7 +132,7 @@ filters for that column, hide property columns in the current view without
 changing other views, and resize column widths. Column headers show compact
 sort/filter indicators when that column has active view constraints. Table
 rows can be selected with row checkboxes, and the table shows a compact
-selected-row bar with clear, duplicate, confirmed delete, and bulk property
+selected-row bar with clear, duplicate, confirmed membership removal, and bulk property
 set actions for editable non-computed fields. Empty table cells stay
 visually blank while remaining clickable for editing, and checkbox table
 cells render as compact checkbox glyphs instead of "Checked"/"Unchecked"
@@ -228,16 +228,18 @@ property definition.
 Use `create-content-database`, `create-inline-content-database`,
 `get-content-database`, `list-trashed-content-databases`,
 `restore-content-database`, `add-database-item`, `duplicate-database-item`,
-`duplicate-database-items`, `delete-database-items`, `move-database-item`,
+`duplicate-database-items`, `remove-database-items`, `move-database-item`,
 `update-content-database-view`, `list-document-properties`,
 `configure-document-property`, `set-document-property`,
 `duplicate-document-property`, and `delete-document-property`; do not edit
 property rows or view config via raw SQL when an action can do it.
 
 When targeting more than one database row, call `duplicate-database-items` or
-`delete-database-items` once with a native JSON array of `itemIds` or
+`remove-database-items` once with a native JSON array of `itemIds` or
 `documentIds`. Do not loop `duplicate-database-item` or `delete-document` for
-multi-row duplicate/delete requests.
+multi-row duplicate or membership-removal requests. Removing a row from a
+database preserves its Page, descendants, other database memberships, and
+unrelated property values.
 
 Database views follow Notion-style tab labels. When creating or duplicating
 views in `viewConfig`, use unique default names (`Table 2`, `SEO copy 2`,

package/corpus/templates/content/actions/_database-membership-lock.ts

@@ -0,0 +1,25 @@
+import { inArray, sql } from "drizzle-orm";
+
+import { schema } from "../server/db/index.js";
+import { chunks } from "./_batch-utils.js";
+
+export async function lockDatabaseMemberships(db: any, itemIds: string[]) {
+  const uniqueItemIds = [...new Set(itemIds)].sort();
+  if (uniqueItemIds.length === 0) return;
+  const lockedIds = new Set<string>();
+  for (const itemIdChunk of chunks(uniqueItemIds, 90)) {
+    const lockedRows = await db
+      .update(schema.contentDatabaseItems)
+      .set({
+        updatedAt: sql`${schema.contentDatabaseItems.updatedAt}`,
+      })
+      .where(inArray(schema.contentDatabaseItems.id, itemIdChunk))
+      .returning({ id: schema.contentDatabaseItems.id });
+    for (const row of lockedRows) lockedIds.add(row.id);
+  }
+  if (lockedIds.size !== uniqueItemIds.length) {
+    throw new Error(
+      "Database memberships changed before the operation completed.",
+    );
+  }
+}

package/corpus/templates/content/actions/_database-row-batch.ts

@@ -79,6 +79,7 @@ function positionCaseSql(
 
 export async function resolveDatabaseRowsForBatch(
   input: DatabaseRowBatchInput,
+  options: { includeTrashed?: boolean } = {},
 ): Promise<{
   database: typeof schema.contentDatabases.$inferSelect;
   rows: DatabaseRowBatchRow[];
@@ -151,7 +152,7 @@ export async function resolveDatabaseRowsForBatch(
         eq(schema.contentDatabaseItems.databaseId, database.id),
         rowPredicates.length === 1 ? rowPredicates[0] : or(...rowPredicates),
         isNull(schema.contentDatabases.deletedAt),
-        isNull(schema.documents.trashedAt),
+        options.includeTrashed ? undefined : isNull(schema.documents.trashedAt),
       ),
     )
     .orderBy(asc(schema.contentDatabaseItems.position));
@@ -177,7 +178,10 @@ export async function resolveDatabaseRowsForBatch(
     throw new Error("Duplicate database row references are not allowed.");
   }
 
-  return { database, rows: requestedRows };
+  return {
+    database,
+    rows: requestedRows,
+  };
 }
 
 export async function renumberDatabaseRows(