@agent-native/core 0.178.1-nightly-20260910175201 → 0.178.1

package/corpus/templates/clips/server/lib/clip-intake.ts

@@ -0,0 +1,247 @@
+import { verifyScopedAgentAccessToken } from "@agent-native/core/server";
+import { and, eq, gt, inArray } from "drizzle-orm";
+import { createError, getQuery, type H3Event } from "h3";
+
+import {
+  CLIP_INTAKE_RESOURCE_KIND,
+  parseClipIntakeParams,
+} from "../../shared/clip-intake.js";
+import { getDb, schema } from "../db/index.js";
+import { ownerEmailMatches } from "./recordings.js";
+
+export type ClipIntakeSession = typeof schema.clipIntakeSessions.$inferSelect;
+
+export interface ClipIntakeRequestContext {
+  recordingId: string;
+  ownerEmail: string;
+  orgId: string;
+}
+
+function queryParams(event: H3Event): URLSearchParams {
+  const query = getQuery(event);
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    const first = Array.isArray(value) ? value[0] : value;
+    if (first !== undefined && first !== null) params.set(key, String(first));
+  }
+  return params;
+}
+
+function intakeIsExpired(
+  session: ClipIntakeSession,
+  now = Date.now(),
+): boolean {
+  const expiresAt = Date.parse(session.expiresAt);
+  return !Number.isFinite(expiresAt) || expiresAt <= now;
+}
+
+export async function findClipIntakeSession(
+  intakeId: string,
+  token: string,
+): Promise<ClipIntakeSession | null> {
+  const verified = verifyScopedAgentAccessToken(token, {
+    resourceKind: CLIP_INTAKE_RESOURCE_KIND,
+    resourceId: intakeId,
+  });
+  if (!verified.ok) return null;
+
+  const [session] = await getDb()
+    .select()
+    .from(schema.clipIntakeSessions)
+    .where(eq(schema.clipIntakeSessions.id, intakeId))
+    .limit(1);
+  if (!session || intakeIsExpired(session)) return null;
+  return session;
+}
+
+export async function findOwnedClipIntakeSession(
+  intakeId: string,
+  ownerEmail: string,
+  organizationId: string,
+): Promise<ClipIntakeSession | null> {
+  const [session] = await getDb()
+    .select()
+    .from(schema.clipIntakeSessions)
+    .where(
+      and(
+        eq(schema.clipIntakeSessions.id, intakeId),
+        ownerEmailMatches(schema.clipIntakeSessions.ownerEmail, ownerEmail),
+        eq(schema.clipIntakeSessions.organizationId, organizationId),
+      ),
+    )
+    .limit(1);
+  if (!session || intakeIsExpired(session)) return null;
+  return session;
+}
+
+export async function requireClipIntakeSession(
+  intakeId: string,
+  token: string,
+): Promise<ClipIntakeSession> {
+  const session = await findClipIntakeSession(intakeId, token);
+  if (!session) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Invalid or expired intake link",
+    });
+  }
+  return session;
+}
+
+export async function resolveClipIntakeRequest(
+  event: H3Event,
+  recordingId: string,
+): Promise<ClipIntakeRequestContext> {
+  const params = parseClipIntakeParams(queryParams(event));
+  if (!params) {
+    throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+  }
+  const session = await requireClipIntakeSession(params.intakeId, params.token);
+  if (
+    !session.recordingId ||
+    session.recordingId !== recordingId ||
+    session.status !== "recording"
+  ) {
+    throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+  }
+  return {
+    recordingId,
+    ownerEmail: session.ownerEmail,
+    orgId: session.organizationId,
+  };
+}
+
+export async function resolveClipIntakeStatusRequest(
+  event: H3Event,
+  recordingId: string,
+): Promise<ClipIntakeSession> {
+  const params = parseClipIntakeParams(queryParams(event));
+  if (!params) {
+    throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+  }
+  const session = await requireClipIntakeSession(params.intakeId, params.token);
+  if (
+    !session.recordingId ||
+    session.recordingId !== recordingId ||
+    !["recording", "completed"].includes(session.status)
+  ) {
+    throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+  }
+  return session;
+}
+
+export async function claimClipIntakeRecording(
+  intakeId: string,
+  token: string,
+): Promise<ClipIntakeSession | null> {
+  const session = await findClipIntakeSession(intakeId, token);
+  if (!session || session.status !== "open") return null;
+  const [claimed] = await getDb()
+    .update(schema.clipIntakeSessions)
+    .set({ status: "creating", updatedAt: new Date().toISOString() })
+    .where(
+      and(
+        eq(schema.clipIntakeSessions.id, intakeId),
+        eq(schema.clipIntakeSessions.status, "open"),
+        eq(schema.clipIntakeSessions.expiresAt, session.expiresAt),
+        gt(schema.clipIntakeSessions.expiresAt, new Date().toISOString()),
+      ),
+    )
+    .returning();
+  return claimed ?? null;
+}
+
+export async function findRecoverableClipIntakeRecording(
+  session: ClipIntakeSession,
+): Promise<{ id: string; organizationId: string } | null> {
+  if (session.status !== "recording" || !session.recordingId) return null;
+
+  const [recording] = await getDb()
+    .select({
+      id: schema.recordings.id,
+      organizationId: schema.recordings.organizationId,
+      status: schema.recordings.status,
+    })
+    .from(schema.recordings)
+    .where(
+      and(
+        eq(schema.recordings.id, session.recordingId),
+        ownerEmailMatches(schema.recordings.ownerEmail, session.ownerEmail),
+        eq(schema.recordings.organizationId, session.organizationId),
+      ),
+    )
+    .limit(1);
+
+  return recording?.status === "uploading"
+    ? { id: recording.id, organizationId: recording.organizationId }
+    : null;
+}
+
+export async function releaseClipIntakeCreation(
+  intakeId: string,
+): Promise<void> {
+  await getDb()
+    .update(schema.clipIntakeSessions)
+    .set({ status: "open", updatedAt: new Date().toISOString() })
+    .where(
+      and(
+        eq(schema.clipIntakeSessions.id, intakeId),
+        eq(schema.clipIntakeSessions.status, "creating"),
+      ),
+    );
+}
+
+export async function attachClipIntakeRecording(
+  intakeId: string,
+  recordingId: string,
+): Promise<void> {
+  const [updated] = await getDb()
+    .update(schema.clipIntakeSessions)
+    .set({
+      recordingId,
+      status: "recording",
+      updatedAt: new Date().toISOString(),
+    })
+    .where(
+      and(
+        eq(schema.clipIntakeSessions.id, intakeId),
+        eq(schema.clipIntakeSessions.status, "creating"),
+      ),
+    )
+    .returning({ id: schema.clipIntakeSessions.id });
+  if (!updated) throw new Error("Could not attach recording to intake session");
+}
+
+export async function completeClipIntake(
+  intakeId: string,
+  recordingId: string,
+): Promise<void> {
+  await getDb()
+    .update(schema.clipIntakeSessions)
+    .set({ status: "completed", updatedAt: new Date().toISOString() })
+    .where(
+      and(
+        eq(schema.clipIntakeSessions.id, intakeId),
+        eq(schema.clipIntakeSessions.recordingId, recordingId),
+        inArray(schema.clipIntakeSessions.status, ["recording", "completed"]),
+      ),
+    );
+}
+
+export async function abandonClipIntake(
+  intakeId: string,
+  recordingId?: string,
+): Promise<void> {
+  await getDb()
+    .update(schema.clipIntakeSessions)
+    .set({ status: "aborted", updatedAt: new Date().toISOString() })
+    .where(
+      and(
+        eq(schema.clipIntakeSessions.id, intakeId),
+        inArray(schema.clipIntakeSessions.status, ["creating", "recording"]),
+        ...(recordingId
+          ? [eq(schema.clipIntakeSessions.recordingId, recordingId)]
+          : []),
+      ),
+    );
+}

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

@@ -38,6 +38,14 @@ export default createAuthPlugin({
     // for signed-in viewers and redirects anonymous viewers to /share/:id.
     "/r",
     "/bug-report",
+    // The recorder is public only so a signed intake URL can reach the
+    // browser capture UI. Recording creation and upload remain token-scoped.
+    "/record",
+    // Anonymous intake is a signed, write-only capability. The recording
+    // action and transport handlers perform their own token and recording-
+    // scope checks. Agent-link exchange stays behind normal auth.
+    "/_agent-native/actions/create-intake-recording",
+    "/api/clip-intake",
     // React Router's lazy route-discovery endpoint. If this is gated by
     // auth it returns an HTML login page; the client tries to parse it
     // as JSON, fails, and can't resolve any public route the user lands

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

@@ -1229,6 +1229,22 @@ export const migrations = runMigrations(
         ALTER TABLE IF EXISTS calendar_account_shares ADD COLUMN IF NOT EXISTS notified_at TEXT
       `,
     },
+    {
+      version: 72,
+      name: "clips-intake-sessions",
+      sql: `CREATE TABLE IF NOT EXISTS clips_intake_sessions (
+        id TEXT PRIMARY KEY,
+        owner_email TEXT NOT NULL,
+        organization_id TEXT NOT NULL,
+        recording_id TEXT,
+        status TEXT NOT NULL DEFAULT 'open',
+        expires_at TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (CURRENT_TIMESTAMP),
+        updated_at TEXT NOT NULL DEFAULT (CURRENT_TIMESTAMP)
+      );
+      CREATE INDEX IF NOT EXISTS clips_intake_sessions_expires_idx
+        ON clips_intake_sessions (status, expires_at)`,
+    },
   ],
   { table: "clips_migrations" },
 );

package/corpus/templates/clips/server/routes/api/clip-intake.get.ts

@@ -0,0 +1,61 @@
+// guard:allow-api-route - anonymous intake status is a signed recovery transport, not a CRUD API.
+
+import { and, eq } from "drizzle-orm";
+import { defineEventHandler, getQuery, type H3Event } from "h3";
+
+import { getDb, schema } from "../../db/index.js";
+import {
+  completeClipIntake,
+  resolveClipIntakeStatusRequest,
+} from "../../lib/clip-intake.js";
+import { ownerEmailMatches } from "../../lib/recordings.js";
+
+function queryString(event: H3Event, key: string): string | null {
+  const value = getQuery(event)[key];
+  const first = Array.isArray(value) ? value[0] : value;
+  return typeof first === "string" && first.trim() ? first.trim() : null;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  if (queryString(event, "operation") !== "status") {
+    return { recording: null };
+  }
+
+  const recordingId = queryString(event, "recordingId");
+  if (!recordingId || recordingId.length > 200 || /[\r\n]/.test(recordingId)) {
+    return { recording: null };
+  }
+
+  const session = await resolveClipIntakeStatusRequest(event, recordingId);
+  const [recording] = await getDb()
+    .select({
+      id: schema.recordings.id,
+      status: schema.recordings.status,
+      videoUrl: schema.recordings.videoUrl,
+    })
+    .from(schema.recordings)
+    .where(
+      and(
+        eq(schema.recordings.id, recordingId),
+        ownerEmailMatches(schema.recordings.ownerEmail, session.ownerEmail),
+        eq(schema.recordings.organizationId, session.organizationId),
+      ),
+    )
+    .limit(1);
+
+  if (!recording) return { recording: null };
+
+  if (recording.status === "ready" && recording.videoUrl) {
+    await completeClipIntake(session.id, recordingId);
+  }
+
+  return {
+    recording: {
+      id: recording.id,
+      status: recording.status,
+      ...(recording.status === "processing" && recording.videoUrl
+        ? { verificationPending: true }
+        : {}),
+    },
+  };
+});

package/corpus/templates/clips/server/routes/api/clip-intake.post.ts

@@ -0,0 +1,90 @@
+// guard:allow-api-route - anonymous intake is a signed upload transport, not a CRUD API.
+
+import { createError, defineEventHandler, getQuery, type H3Event } from "h3";
+
+import {
+  abandonClipIntake,
+  completeClipIntake,
+  resolveClipIntakeRequest,
+} from "../../lib/clip-intake.js";
+import { handleAbortRecordingUpload } from "./uploads/[recordingId]/abort.post.js";
+import { handleRecordingChunk } from "./uploads/[recordingId]/chunk.post.js";
+import { handleResetRecordingChunks } from "./uploads/[recordingId]/reset-chunks.post.js";
+
+function queryString(event: H3Event, key: string): string | null {
+  const value = getQuery(event)[key];
+  const first = Array.isArray(value) ? value[0] : value;
+  return typeof first === "string" && first.trim() ? first.trim() : null;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  const recordingId = queryString(event, "recordingId");
+  if (!recordingId || recordingId.length > 200 || /[\r\n]/.test(recordingId)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Missing recordingId",
+    });
+  }
+
+  const operation = queryString(event, "operation");
+  if (operation !== "chunk" && operation !== "abort" && operation !== "reset") {
+    throw createError({
+      statusCode: 405,
+      statusMessage: "Unsupported operation",
+    });
+  }
+
+  const access = await resolveClipIntakeRequest(event, recordingId);
+  const intakeId = queryString(event, "clip_intake_id");
+  const override = {
+    recordingId,
+    ownerEmail: access.ownerEmail,
+    orgId: access.orgId,
+  };
+
+  if (operation === "reset") {
+    return handleResetRecordingChunks(event, override);
+  }
+
+  if (operation === "abort") {
+    const result = await handleAbortRecordingUpload(event, override);
+    const body =
+      result && typeof result === "object"
+        ? (result as Record<string, unknown>)
+        : null;
+    if (body?.ok === true) {
+      if (body.alreadyReady === true || body.verificationPending === true) {
+        if (intakeId) await completeClipIntake(intakeId, recordingId);
+      } else if (intakeId) {
+        await abandonClipIntake(intakeId, recordingId);
+      }
+    }
+    return result;
+  }
+
+  const result = await handleRecordingChunk(event, override);
+  const body =
+    result && typeof result === "object"
+      ? (result as Record<string, unknown>)
+      : null;
+  if (body?.status === "failed" || body?.aborted === true) {
+    if (intakeId) await abandonClipIntake(intakeId, recordingId);
+  } else if (
+    body &&
+    (body.finalized === true ||
+      body.verificationPending === true ||
+      body.waitingForStorage === true)
+  ) {
+    if (intakeId) await completeClipIntake(intakeId, recordingId);
+  }
+
+  if (!body) return result;
+  const {
+    videoUrl: _videoUrl,
+    thumbnailUrl: _thumbnailUrl,
+    animatedThumbnailUrl: _animatedThumbnailUrl,
+    filmstripUrl: _filmstripUrl,
+    ...safeResult
+  } = body;
+  return safeResult;
+});

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/abort.post.ts

@@ -34,14 +34,27 @@ import {
 } from "../../../../lib/resumable-session.js";
 import { resolveResumableUploadProvider } from "../../../../lib/resumable-upload-provider.js";
 
-export default defineEventHandler(async (event: H3Event) => {
-  const recordingId = getRouterParam(event, "recordingId");
+export async function handleAbortRecordingUpload(
+  event: H3Event,
+  override?: {
+    recordingId?: string;
+    ownerEmail?: string;
+    orgId?: string;
+  },
+) {
+  const recordingId =
+    override?.recordingId ?? getRouterParam(event, "recordingId");
   if (!recordingId) {
     setResponseStatus(event, 400);
     return { error: "Missing recordingId" };
   }
 
-  const { userEmail: ownerEmail, orgId } = await getEventOwnerContext(event);
+  const { ownerEmail, orgId } = override?.ownerEmail
+    ? { ownerEmail: override.ownerEmail, orgId: override.orgId }
+    : await getEventOwnerContext(event).then((context) => ({
+        ownerEmail: context.userEmail,
+        orgId: context.orgId,
+      }));
   const body = (await readBody(event).catch(() => null)) as {
     reason?: unknown;
     attemptId?: unknown;
@@ -263,4 +276,6 @@ export default defineEventHandler(async (event: H3Event) => {
 
     return { ok: true, recordingId, chunksCleared: cleared };
   });
-});
+}
+
+export default defineEventHandler((event) => handleAbortRecordingUpload(event));

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -198,8 +198,16 @@ function trackUploadBlockingFailure(
   }
 }
 
-export default defineEventHandler(async (event: H3Event) => {
-  const recordingId = getRouterParam(event, "recordingId");
+export async function handleRecordingChunk(
+  event: H3Event,
+  override?: {
+    recordingId?: string;
+    ownerEmail?: string;
+    orgId?: string;
+  },
+) {
+  const recordingId =
+    override?.recordingId ?? getRouterParam(event, "recordingId");
   if (!recordingId) {
     throw createError({ statusCode: 400, message: "Missing recordingId" });
   }
@@ -264,13 +272,18 @@ export default defineEventHandler(async (event: H3Event) => {
 
   let ownerEmail: string;
   let orgId: string | undefined;
-  try {
-    const context = await getEventOwnerContext(event);
-    ownerEmail = context.userEmail;
-    orgId = context.orgId;
-  } catch (err) {
-    console.error("[chunk] getEventOwnerContext threw:", err);
-    throw createError({ statusCode: 401, message: "Unauthorized" });
+  if (override?.ownerEmail) {
+    ownerEmail = override.ownerEmail;
+    orgId = override.orgId;
+  } else {
+    try {
+      const context = await getEventOwnerContext(event);
+      ownerEmail = context.userEmail;
+      orgId = context.orgId;
+    } catch (err) {
+      console.error("[chunk] getEventOwnerContext threw:", err);
+      throw createError({ statusCode: 401, message: "Unauthorized" });
+    }
   }
   debugLog("[chunk] resolved owner:", ownerEmail);
 
@@ -821,7 +834,9 @@ export default defineEventHandler(async (event: H3Event) => {
 
     return { ok: true, finalized: false, index, bytes: bytes.byteLength };
   });
-});
+}
+
+export default defineEventHandler((event) => handleRecordingChunk(event));
 
 function buildFinalizeArgs(
   recordingId: string,

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/reset-chunks.post.ts

@@ -158,14 +158,27 @@ function pickString(value: unknown, max: number): string | undefined {
   return trimmed.slice(0, max);
 }
 
-export default defineEventHandler(async (event: H3Event) => {
-  const recordingId = getRouterParam(event, "recordingId");
+export async function handleResetRecordingChunks(
+  event: H3Event,
+  override?: {
+    recordingId?: string;
+    ownerEmail?: string;
+    orgId?: string;
+  },
+) {
+  const recordingId =
+    override?.recordingId ?? getRouterParam(event, "recordingId");
   if (!recordingId) {
     setResponseStatus(event, 400);
     return { error: "Missing recordingId" };
   }
 
-  const { userEmail: ownerEmail, orgId } = await getEventOwnerContext(event);
+  const { ownerEmail, orgId } = override?.ownerEmail
+    ? { ownerEmail: override.ownerEmail, orgId: override.orgId }
+    : await getEventOwnerContext(event).then(({ userEmail, orgId }) => ({
+        ownerEmail: userEmail,
+        orgId,
+      }));
   const body = (await readBody(event).catch(() => null)) as {
     compression?: CompressionMeta | null;
     requestStreaming?: boolean;
@@ -593,4 +606,8 @@ export default defineEventHandler(async (event: H3Event) => {
       uploadGenerationId: nextGenerationId,
     };
   });
-});
+}
+
+export default defineEventHandler((event: H3Event) =>
+  handleResetRecordingChunks(event),
+);

package/corpus/templates/clips/shared/clip-intake.ts

@@ -0,0 +1,41 @@
+export const CLIP_INTAKE_RESOURCE_KIND = "clip-intake";
+export const CLIP_INTAKE_TOKEN_PARAM = "clip_intake";
+export const CLIP_INTAKE_ID_PARAM = "clip_intake_id";
+export const CLIP_INTAKE_DEFAULT_TTL_SECONDS = 60 * 60;
+export const CLIP_INTAKE_MAX_TTL_SECONDS = 4 * 60 * 60;
+
+export interface ClipIntakeParams {
+  intakeId: string;
+  token: string;
+}
+
+function queryValue(params: URLSearchParams, key: string): string | null {
+  const value = params.get(key)?.trim() ?? "";
+  return value || null;
+}
+
+export function parseClipIntakeParams(
+  params: URLSearchParams,
+): ClipIntakeParams | null {
+  const intakeId = queryValue(params, CLIP_INTAKE_ID_PARAM);
+  const token = queryValue(params, CLIP_INTAKE_TOKEN_PARAM);
+  if (!intakeId || !token) return null;
+  if (!/^[A-Za-z0-9_-]{16,80}$/.test(intakeId)) return null;
+  if (token.length > 4096 || /[\r\n]/.test(token)) return null;
+  return { intakeId, token };
+}
+
+export function buildClipIntakeUrl(
+  path: string,
+  params: ClipIntakeParams & {
+    recordingId: string;
+    operation: "chunk" | "abort" | "reset";
+  },
+): string {
+  const url = new URL(path, "https://clips-intake.invalid");
+  url.searchParams.set("recordingId", params.recordingId);
+  url.searchParams.set("operation", params.operation);
+  url.searchParams.set(CLIP_INTAKE_ID_PARAM, params.intakeId);
+  url.searchParams.set(CLIP_INTAKE_TOKEN_PARAM, params.token);
+  return `${url.pathname}${url.search}`;
+}