@agent-native/core 0.90.11 → 0.91.0

package/corpus/templates/clips/chrome-extension/src/popup.ts

@@ -22,6 +22,13 @@ type InputDevice = {
   label: string;
 };
 
+type InputDevices = {
+  cameras: InputDevice[];
+  microphones: InputDevice[];
+  defaultCameraName: string;
+  defaultMicrophoneName: string;
+};
+
 type PopupStartResponse = {
   ok?: boolean;
   error?: string;
@@ -59,6 +66,11 @@ type PopupStatusResponse = {
 
 type AuthStatus = "checking" | "signed-in" | "signed-out";
 
+type CachedMediaPermission = {
+  camera?: boolean;
+  microphone?: boolean;
+};
+
 type StoredAuth = {
   token: string;
   email?: string;
@@ -205,35 +217,66 @@ function isVirtualDefaultDevice(device: MediaDeviceInfo): boolean {
   return VIRTUAL_DEVICE_ID_RE.test(device.deviceId);
 }
 
+function isSystemDefaultDevice(device: MediaDeviceInfo): boolean {
+  return /^default$/i.test(device.deviceId);
+}
+
+function normalizeDefaultDeviceName(label: string): string {
+  const value = label.trim();
+  const parenthesized = value.match(/^default\s*\((.+)\)$/i);
+  const normalized = (parenthesized?.[1] ?? value)
+    .replace(/^default\s*[-–—:]\s*/i, "")
+    .replace(/\s*\((?:default|communications)\)\s*$/i, "")
+    .trim();
+  return /^(?:default|communications)$/i.test(normalized) ? "" : normalized;
+}
+
 // Enumerate the user's input devices for the camera/mic pickers. Labels only
 // populate after camera/mic permission is granted (the extension's permission
 // onboarding page handles that), so fall back to a generic label otherwise.
-async function enumerateInputDevices(): Promise<{
-  cameras: InputDevice[];
-  microphones: InputDevice[];
-}> {
+async function enumerateInputDevices(): Promise<InputDevices> {
   try {
     const devices = await navigator.mediaDevices.enumerateDevices();
     const cameras: InputDevice[] = [];
     const microphones: InputDevice[] = [];
+    let defaultCameraName = "";
+    let defaultMicrophoneName = "";
     for (const device of devices) {
       if (!device.deviceId) continue;
-      if (isVirtualDefaultDevice(device)) continue;
+      const label = device.label.trim();
+      if (isVirtualDefaultDevice(device)) {
+        if (isSystemDefaultDevice(device)) {
+          const defaultName = normalizeDefaultDeviceName(label);
+          if (device.kind === "videoinput") defaultCameraName ||= defaultName;
+          if (device.kind === "audioinput") {
+            defaultMicrophoneName ||= defaultName;
+          }
+        }
+        continue;
+      }
       if (device.kind === "videoinput") {
+        defaultCameraName ||= label;
         cameras.push({
           deviceId: device.deviceId,
-          label: device.label.trim() || `Camera ${cameras.length + 1}`,
+          label: label || `Camera ${cameras.length + 1}`,
         });
-      } else if (isSelectableAudioInputDevice(device)) {
+      } else if (device.kind === "audioinput") {
+        defaultMicrophoneName ||= label;
+        if (!isSelectableAudioInputDevice(device)) continue;
         microphones.push({
           deviceId: device.deviceId,
-          label: device.label.trim() || `Microphone ${microphones.length + 1}`,
+          label: label || `Microphone ${microphones.length + 1}`,
         });
       }
     }
-    return { cameras, microphones };
+    return { cameras, microphones, defaultCameraName, defaultMicrophoneName };
   } catch {
-    return { cameras: [], microphones: [] };
+    return {
+      cameras: [],
+      microphones: [],
+      defaultCameraName: "",
+      defaultMicrophoneName: "",
+    };
   }
 }
 
@@ -368,20 +411,41 @@ function createTab(url: string): Promise<void> {
   });
 }
 
-async function permissionGranted(
+function permissionPageUrl(settings: ExtensionSettings): string {
+  const url = new URL(chrome.runtime.getURL("src/permission.html"));
+  url.searchParams.set("startAfterGrant", "1");
+  url.searchParams.set(
+    "needsCamera",
+    String(settings.captureSurface === "camera" || settings.includeCamera),
+  );
+  url.searchParams.set("needsMicrophone", String(settings.includeMicrophone));
+  return url.toString();
+}
+
+async function mediaPermissionState(
   name: "camera" | "microphone",
-): Promise<boolean> {
+): Promise<PermissionState | "unknown"> {
   try {
     const status = await navigator.permissions.query({
       name: name as PermissionName,
     });
-    return status.state === "granted";
+    return status.state;
   } catch {
-    // Older Chrome can't query these names — don't block; getUserMedia will ask.
-    return true;
+    return "unknown";
   }
 }
 
+function readCachedMediaPermission(): Promise<CachedMediaPermission> {
+  return new Promise((resolve) => {
+    chrome.storage.local.get("clipsMediaPermission", (value) => {
+      const cached = value.clipsMediaPermission as
+        | CachedMediaPermission
+        | undefined;
+      resolve(cached && typeof cached === "object" ? cached : {});
+    });
+  });
+}
+
 // True when every device the chosen mode needs is already granted to the
 // extension. If not, the caller routes the user to the permission page.
 async function ensureMediaPermission(
@@ -390,8 +454,17 @@ async function ensureMediaPermission(
   const needsCamera =
     settings.captureSurface === "camera" || settings.includeCamera;
   const needsMic = settings.includeMicrophone;
-  if (needsCamera && !(await permissionGranted("camera"))) return false;
-  if (needsMic && !(await permissionGranted("microphone"))) return false;
+  const cached = await readCachedMediaPermission();
+  if (needsCamera) {
+    const state = await mediaPermissionState("camera");
+    if (state === "denied") return false;
+    if (state !== "granted" && cached.camera !== true) return false;
+  }
+  if (needsMic) {
+    const state = await mediaPermissionState("microphone");
+    if (state === "denied") return false;
+    if (state !== "granted" && cached.microphone !== true) return false;
+  }
   return true;
 }
 
@@ -574,9 +647,11 @@ function renderSource(settings: ExtensionSettings): void {
 
 // Holds the most recent device enumeration so the menus and labels can render
 // without re-querying on every paint. Refreshed by refreshDevices().
-let inputDevices: { cameras: InputDevice[]; microphones: InputDevice[] } = {
+let inputDevices: InputDevices = {
   cameras: [],
   microphones: [],
+  defaultCameraName: "",
+  defaultMicrophoneName: "",
 };
 
 // Distinguishes "the user explicitly picked the OS default" from "the id we
@@ -594,6 +669,10 @@ function deviceLabel(
   return match ? match.label : `${fallback} (device disconnected)`;
 }
 
+function defaultDeviceLabel(fallback: string, deviceName: string): string {
+  return deviceName ? `${fallback} (${deviceName})` : fallback;
+}
+
 function renderDeviceMenu(
   menu: HTMLDivElement,
   devices: InputDevice[],
@@ -640,16 +719,20 @@ function renderDevicePickers(settings: ExtensionSettings): void {
     settings.captureSurface === "camera" || settings.includeCamera;
   cameraButton.hidden = !showCamera;
   if (showCamera) {
+    const defaultCameraLabel = defaultDeviceLabel(
+      "System default",
+      inputDevices.defaultCameraName,
+    );
     cameraLabel.textContent = deviceLabel(
       inputDevices.cameras,
       settings.videoDeviceId,
-      "System default",
+      defaultCameraLabel,
     );
     renderDeviceMenu(
       cameraMenu,
       inputDevices.cameras,
       settings.videoDeviceId,
-      "System default",
+      defaultCameraLabel,
     );
   } else {
     cameraMenu.hidden = true;
@@ -661,16 +744,20 @@ function renderDevicePickers(settings: ExtensionSettings): void {
   const micMenu = byId<HTMLDivElement>("microphone-device-menu");
   micButton.hidden = !settings.includeMicrophone;
   if (settings.includeMicrophone) {
+    const defaultMicrophoneLabel = defaultDeviceLabel(
+      "System default",
+      inputDevices.defaultMicrophoneName,
+    );
     micLabel.textContent = deviceLabel(
       inputDevices.microphones,
       settings.audioDeviceId,
-      "System default",
+      defaultMicrophoneLabel,
     );
     renderDeviceMenu(
       micMenu,
       inputDevices.microphones,
       settings.audioDeviceId,
-      "System default",
+      defaultMicrophoneLabel,
     );
   } else {
     micMenu.hidden = true;
@@ -1187,9 +1274,22 @@ async function init(): Promise<void> {
       // there (a real extension page) is the only place Chrome reliably shows the
       // permission dialog and persists the grant for the offscreen recorder + bubble.
       if (!(await ensureMediaPermission(settings))) {
+        const prepare = await sendRuntimeMessage<PopupStartResponse>({
+          type: "CLIPS_POPUP_PREPARE_PERMISSION_START",
+          settings,
+          targetTabId: activeTab?.id,
+        });
+        if (!prepare.ok) {
+          start.disabled = false;
+          setStatus(
+            prepare.error || "Could not prepare the recording tab.",
+            "error",
+          );
+          return;
+        }
         start.disabled = false;
         setStatus("Allow camera & microphone, then start recording.", "error");
-        await createTab(chrome.runtime.getURL("src/permission.html"));
+        await createTab(permissionPageUrl(settings));
         window.close();
         return;
       }

package/corpus/templates/content/actions/_builder-cms-read-client.ts

@@ -321,12 +321,35 @@ function normalizeBuilderCmsModel(
           const fieldName =
             typeof fieldRecord.name === "string" ? fieldRecord.name.trim() : "";
           if (!fieldName) return null;
+          const inputType =
+            typeof fieldRecord.inputType === "string" &&
+            fieldRecord.inputType.trim()
+              ? fieldRecord.inputType.trim()
+              : typeof fieldRecord.input === "string" &&
+                  fieldRecord.input.trim()
+                ? fieldRecord.input.trim()
+                : undefined;
+          const label =
+            typeof fieldRecord.label === "string" && fieldRecord.label.trim()
+              ? fieldRecord.label.trim()
+              : typeof fieldRecord.friendlyName === "string" &&
+                  fieldRecord.friendlyName.trim()
+                ? fieldRecord.friendlyName.trim()
+                : undefined;
+          const enumOptions = stringOptionsFromUnknown(fieldRecord.enum);
+          const options = stringOptionsFromUnknown(
+            fieldRecord.options ?? fieldRecord.allowedValues,
+          );
           return {
             name: fieldName,
+            ...(label ? { label } : {}),
             type:
               typeof fieldRecord.type === "string" && fieldRecord.type.trim()
                 ? fieldRecord.type.trim()
                 : "unknown",
+            ...(inputType ? { inputType } : {}),
+            ...(enumOptions ? { enum: enumOptions } : {}),
+            ...(options ? { options } : {}),
             required: fieldRecord.required === true,
           };
         })
@@ -338,6 +361,30 @@ function normalizeBuilderCmsModel(
   return { id, name, displayName, kind, fields };
 }
 
+function stringOptionsFromUnknown(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const options = value
+    .map((option) => {
+      if (typeof option === "string" || typeof option === "number") {
+        return String(option).trim();
+      }
+      if (!option || typeof option !== "object") return "";
+      const record = option as Record<string, unknown>;
+      for (const key of ["label", "name", "value"]) {
+        const candidate = record[key];
+        if (typeof candidate === "string" && candidate.trim()) {
+          return candidate.trim();
+        }
+        if (typeof candidate === "number" && Number.isFinite(candidate)) {
+          return String(candidate);
+        }
+      }
+      return "";
+    })
+    .filter(Boolean);
+  return options.length > 0 ? Array.from(new Set(options)) : undefined;
+}
+
 function builderMcpModelsFromToolResponse(
   response: unknown,
 ): BuilderCmsModelSummary[] {

package/corpus/templates/content/actions/_database-source-utils.ts

@@ -43,6 +43,7 @@ import {
 } from "../shared/builder-mdx.js";
 import {
   normalizePropertyValue,
+  normalizePropertyValueWithOptions,
   parsePropertyOptions,
   serializePropertyOptions,
   serializePropertyValue,
@@ -131,6 +132,7 @@ type SourceMetadataRecord = {
   allowPublishWrites?: boolean;
   allowedWriteModes?: ContentDatabaseSourcePushMode[];
   federation?: ContentDatabaseSourceFederation;
+  builderModelFields?: BuilderCmsModelFieldSummary[];
 };
 
 function parseObject<T extends object>(
@@ -1983,8 +1985,8 @@ export async function getContentDatabaseSourceSnapshotForWrite(
   database: ContentDatabaseRow | ContentDatabase,
   sourceId?: string | null,
 ): Promise<ContentDatabaseSource | null> {
+  const db = getDb();
   if (sourceId) {
-    const db = getDb();
     const [source] = await db
       .select()
       .from(schema.contentDatabaseSources)
@@ -2000,7 +2002,6 @@ export async function getContentDatabaseSourceSnapshotForWrite(
         })
       : null;
   }
-  const db = getDb();
   const [source] = await db
     .select()
     .from(schema.contentDatabaseSources)
@@ -2647,10 +2648,19 @@ export function normalizeSourceFederation(
 export function serializeSourceMetadataRecord(args: {
   sourceType: ContentDatabaseSourceType;
   sourceTable: string;
+  builderModelFields?: BuilderCmsModelFieldSummary[];
+  existingMetadataJson?: string | null;
 }) {
   const isBuilder = args.sourceType === "builder-cms";
   if (isBuilder) {
-    return JSON.stringify(builderCmsSourceMetadata(args.sourceTable));
+    const existingMetadata = parseObject<SourceMetadataRecord>(
+      args.existingMetadataJson,
+    );
+    return JSON.stringify({
+      ...builderCmsSourceMetadata(args.sourceTable),
+      builderModelFields:
+        args.builderModelFields ?? existingMetadata?.builderModelFields,
+    });
   }
   return JSON.stringify({
     primaryKey: "id",
@@ -2672,9 +2682,16 @@ export function serializeBuilderCmsSourceReadMetadataRecord(args: {
   progress?: BuilderCmsReadProgress;
   sourceFetchState?: "idle" | "fetching" | "error";
   activeReadSourceRowIds?: string[];
+  builderModelFields?: BuilderCmsModelFieldSummary[];
+  existingMetadataJson?: string | null;
 }) {
+  const existingMetadata = parseObject<SourceMetadataRecord>(
+    args.existingMetadataJson,
+  );
   return JSON.stringify({
     ...builderCmsSourceMetadata(args.sourceTable),
+    builderModelFields:
+      args.builderModelFields ?? existingMetadata?.builderModelFields,
     readMode: args.readState === "live" ? "builder-api" : "fixture",
     liveReadConfigured: args.readState === "live",
     lastReadEntryCount: args.entryCount,
@@ -3196,9 +3213,10 @@ async function materializeSourceFieldPropertyValues(args: {
       const propertyId = field.propertyId!;
       const definition = definitionById.get(propertyId);
       if (!definition) continue;
-      const normalized = normalizePropertyValue(
+      const normalized = normalizePropertyValueWithOptions(
         definition.type as DocumentProperty["definition"]["type"],
         sourceValues[field.sourceFieldKey],
+        parsePropertyOptions(definition.optionsJson),
       );
       if (normalized === null) continue;
       const valueJson = serializePropertyValue(normalized);
@@ -3466,6 +3484,7 @@ export async function resyncMockSourceSnapshot(args: {
       metadataJson: serializeSourceMetadataRecord({
         sourceType: normalizeSourceType(args.source.sourceType),
         sourceTable: args.source.sourceTable,
+        existingMetadataJson: args.source.metadataJson,
       }),
       lastRefreshedAt: args.now,
       lastSourceUpdatedAt: args.now,
@@ -3871,6 +3890,7 @@ export async function resyncBuilderCmsSourceSnapshot(args: {
       fetchedAt: builderRead.fetchedAt,
       now: args.now,
       message: builderRead.message,
+      builderModelFields,
       progress: {
         ...builderRead.progress,
         partial: hasMore,
@@ -3981,6 +4001,7 @@ export async function resyncBuilderCmsSourceSnapshot(args: {
     fetchedAt: builderRead.fetchedAt,
     now: args.now,
     message: builderRead.message,
+    builderModelFields,
     progress: builderRead.progress,
     sourceFetchState: builderRead.state === "error" ? "error" : "idle",
     activeReadSourceRowIds: undefined,
@@ -4082,6 +4103,11 @@ export async function replaceSourceMetadata(args: {
         metadataJson: serializeSourceMetadataRecord({
           sourceType: args.sourceType,
           sourceTable: args.sourceTable,
+          existingMetadataJson:
+            args.source.sourceType === args.sourceType &&
+            args.source.sourceTable === args.sourceTable
+              ? args.source.metadataJson
+              : null,
         }),
         lastRefreshedAt: args.now,
         lastSourceUpdatedAt: args.now,
@@ -4313,6 +4339,7 @@ export async function updateBuilderCmsSourceReadMetadata(args: {
   sourceFetchState?: "idle" | "fetching" | "error";
   activeReadSourceRowIds?: string[];
   syncState?: ContentDatabaseSourceSyncState;
+  builderModelFields?: BuilderCmsModelFieldSummary[];
 }) {
   const db = getDb();
   const [currentSource] = await db
@@ -4336,6 +4363,8 @@ export async function updateBuilderCmsSourceReadMetadata(args: {
       progress: args.progress,
       sourceFetchState: args.sourceFetchState,
       activeReadSourceRowIds: args.activeReadSourceRowIds,
+      builderModelFields: args.builderModelFields,
+      existingMetadataJson: currentSource?.metadataJson,
     }),
   });
   await db