@agent-native/core 0.164.12 → 0.164.17

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8473
+- template files: 8484

package/corpus/templates/analytics/netlify.toml

@@ -22,6 +22,10 @@ AGENT_CHAT_DURABLE_BACKGROUND = "true"
 AGENT_NATIVE_HOSTED_HARNESS = "true"
 AGENT_NATIVE_ENABLE_KEEP_WARM = "1"
 AGENT_NATIVE_DISABLE_KEEP_WARM_BACKGROUND = "1"
+# Keep the public shell close to the current deploy. A stale shell can retain
+# hashed modulepreload URLs after a Netlify asset publish and leave the app on
+# its loading screen while those chunks return 404.
+AGENT_NATIVE_SSR_CACHE = "30s"
 # Analytics owns its schema at release time (`migrate:production` above), so
 # production request functions skip migrations. Preview functions still run
 # request-path migrations because previews do not run the production release

package/corpus/templates/clips/actions/request-transcript.ts

@@ -1526,18 +1526,22 @@ const requestTranscriptAction = defineAction({
             transcribeWithBuilderModelFallback({
               audioBytes: audioMedia.audioBytes,
               mimeType: audioMedia.mimeType,
-              diarize: false,
+              diarize: true,
               instructions: SPEECH_ONLY_TRANSCRIPTION_INSTRUCTIONS,
               timeoutMs: builderTranscriptionTimeoutMs(rec.durationMs),
             }),
         );
 
         const segments = (builderResult.segments ?? [])
-          .map((s) => ({
-            startMs: s.startMs,
-            endMs: s.endMs,
-            text: s.text.trim(),
-          }))
+          .map((s) => {
+            const speaker = s.speakerLabel?.trim();
+            return {
+              startMs: s.startMs,
+              endMs: s.endMs,
+              text: s.text.trim(),
+              ...(speaker ? { speaker } : {}),
+            };
+          })
           .filter((segment) => segment.text);
         const normalizedTranscript = normalizeProviderTranscript(
           builderResult.text,

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

@@ -60,6 +60,10 @@ import {
   chunks,
   processWithConcurrency,
 } from "./_batch-utils.js";
+import {
+  LOCAL_FOLDER_SOURCE_TYPE,
+  localFolderSourceIdentityFromMetadata,
+} from "./_local-folder-source.js";
 export { bulkChunkSizeForColumnCount } from "./_batch-utils.js";
 import {
   readBuilderCmsContentEntry,
@@ -176,6 +180,9 @@ type SourceMetadataRecord = {
   connectionId?: string | null;
   connectionLabel?: string | null;
   truthPolicy?: ContentDatabaseSource["metadata"]["truthPolicy"];
+  syncPolicy?: "manual" | "keep_in_sync";
+  liveBridgeEnabled?: boolean;
+  localIdentity?: unknown;
   liveReadConfigured?: boolean;
   lastReadEntryCount?: number;
   lastReadMatchedRowCount?: number;
@@ -4572,14 +4579,19 @@ async function loadSourceSnapshot(
       ? metadata.writeMode
       : undefined;
   const capabilities = normalizeCapabilities(source.capabilitiesJson);
-  if (normalizedWriteMode) {
+  const sourceType = normalizeSourceType(source.sourceType);
+  if (sourceType === LOCAL_FOLDER_SOURCE_TYPE) {
+    capabilities.liveWritesEnabled =
+      metadata.liveBridgeEnabled === true &&
+      metadata.syncPolicy === "keep_in_sync";
+  } else if (normalizedWriteMode) {
     capabilities.liveWritesEnabled = normalizedWriteMode !== "read_only";
   }
 
   // A local-table source shows the target database's *live* title, so renaming
   // the underlying table is reflected here instead of the name frozen at attach.
   let displaySourceName = source.sourceName;
-  if (normalizeSourceType(source.sourceType) === "local-table") {
+  if (sourceType === "local-table") {
     const [target] = await db
       .select({ title: schema.contentDatabases.title })
       .from(schema.contentDatabases)
@@ -4626,6 +4638,17 @@ async function loadSourceSnapshot(
         metadata.truthPolicy === "reviewed_bidirectional"
           ? metadata.truthPolicy
           : undefined,
+      syncPolicy:
+        metadata.syncPolicy === "manual" ||
+        metadata.syncPolicy === "keep_in_sync"
+          ? metadata.syncPolicy
+          : undefined,
+      liveBridgeEnabled:
+        metadata.liveBridgeEnabled === true &&
+        metadata.syncPolicy === "keep_in_sync",
+      localIdentity: localFolderSourceIdentityFromMetadata(
+        metadata.localIdentity,
+      ),
       liveReadConfigured: metadata.liveReadConfigured === true,
       lastReadEntryCount:
         typeof metadata.lastReadEntryCount === "number"

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

@@ -50,6 +50,7 @@ import {
   getDatabaseMutationContract,
 } from "./_database-row-mutation.js";
 import { getAllContentDatabaseSourceSnapshots } from "./_database-source-utils.js";
+import { serializeDocumentSource } from "./_document-source.js";
 import {
   applyFederatedOverlayValues,
   federateSources,
@@ -443,6 +444,7 @@ function serializeDocument(
     databaseMembership: membership
       ? serializeDatabaseMembership(membership)
       : undefined,
+    source: serializeDocumentSource(doc),
     createdAt: doc.createdAt,
     updatedAt: doc.updatedAt,
   };

package/corpus/templates/content/actions/_local-folder-source.ts

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
 
+import { z } from "zod";
+
 import type {
   ContentDatabaseSourceCapabilities,
   ContentDatabaseSourceTruthPolicy,
@@ -7,6 +9,171 @@ import type {
 
 export const LOCAL_FOLDER_SOURCE_TYPE = "local-folder" as const;
 
+export const localFolderOpaqueIdentitySchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(300)
+  .refine(
+    (value) =>
+      !value.includes("/") &&
+      !value.includes("\\") &&
+      !value.includes("..") &&
+      !value.includes("\0"),
+    "Local source identities must be opaque IDs, not paths.",
+  );
+
+const labelSchema = z.string().trim().min(1).max(200);
+
+export const localFolderSourceConnectionMetadataSchema = z
+  .object({
+    repository: z
+      .object({
+        localId: localFolderOpaqueIdentitySchema,
+        providerBinding: z
+          .object({
+            provider: z.literal("github"),
+            repositoryId: localFolderOpaqueIdentitySchema,
+          })
+          .strict()
+          .optional(),
+      })
+      .strict()
+      .optional(),
+    workingCopy: z
+      .object({
+        id: localFolderOpaqueIdentitySchema,
+        repositoryId: localFolderOpaqueIdentitySchema.optional(),
+        kind: z.enum(["persistent", "temporary"]),
+        name: labelSchema,
+        branch: z.string().trim().min(1).max(300).optional(),
+        commit: z.string().trim().min(1).max(300).optional(),
+        deviceId: localFolderOpaqueIdentitySchema,
+      })
+      .strict()
+      .optional(),
+    liveBridgeEnabled: z.boolean().optional().default(false),
+  })
+  .strict();
+
+export type LocalFolderSourceConnectionMetadata = z.infer<
+  typeof localFolderSourceConnectionMetadataSchema
+>;
+
+export type LocalFolderSourceIdentity = {
+  repository?: {
+    localId: string;
+    providerBinding?: { provider: "github"; repositoryId: string };
+  };
+  workingCopy: {
+    id: string;
+    repositoryId?: string;
+    kind: "persistent" | "temporary";
+    name: string;
+    branch?: string;
+    commit?: string;
+    deviceId: string;
+    localOnly: boolean;
+    shareable: boolean;
+  };
+};
+
+export function localFolderSourceIdentityFromMetadata(
+  value: unknown,
+): LocalFolderSourceIdentity | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  const stored = value as {
+    repository?: unknown;
+    workingCopy?: Record<string, unknown>;
+  };
+  const connectionMetadata =
+    localFolderSourceConnectionMetadataSchema.safeParse({
+      repository: stored.repository,
+      workingCopy: stored.workingCopy
+        ? Object.fromEntries(
+            Object.entries(stored.workingCopy).filter(
+              ([key]) => key !== "localOnly" && key !== "shareable",
+            ),
+          )
+        : undefined,
+    });
+  if (!connectionMetadata.success || !connectionMetadata.data.workingCopy) {
+    return undefined;
+  }
+  try {
+    return normalizeLocalFolderSourceIdentity({
+      connectionId: "stored-local-source",
+      label: connectionMetadata.data.workingCopy.name,
+      connectionMetadata: connectionMetadata.data,
+    });
+  } catch {
+    // coercion-ok: invalid legacy metadata is represented as absent optional identity
+    return undefined;
+  }
+}
+
+export function normalizeLocalFolderSourceIdentity(input: {
+  connectionId: string;
+  label: string;
+  connectionMetadata?: LocalFolderSourceConnectionMetadata;
+}): LocalFolderSourceIdentity {
+  const metadata = localFolderSourceConnectionMetadataSchema.parse(
+    input.connectionMetadata ?? {},
+  );
+  const workingCopy = metadata.workingCopy ?? {
+    id: input.connectionId,
+    kind: "persistent" as const,
+    name: input.label,
+    deviceId: "unknown-device",
+  };
+  if (
+    workingCopy.repositoryId &&
+    (!metadata.repository ||
+      workingCopy.repositoryId !== metadata.repository.localId)
+  ) {
+    throw new Error(
+      "Working-copy repositoryId must match the supplied repository identity.",
+    );
+  }
+  return {
+    ...(metadata.repository ? { repository: metadata.repository } : {}),
+    workingCopy: {
+      ...workingCopy,
+      localOnly: workingCopy.kind === "temporary",
+      shareable: workingCopy.kind !== "temporary",
+    },
+  };
+}
+
+export function localFolderObservedRevision(input: {
+  contentHash: string;
+  metadataHash: string;
+}) {
+  return `sha256:${createHash("sha256")
+    .update(`${input.contentHash}:${input.metadataHash}`)
+    .digest("hex")}`;
+}
+
+export function localFolderSourceFileIdentity(input: {
+  workingCopyId: string;
+  relativePath: string;
+  observedRevision: string;
+}) {
+  const relativePath = input.relativePath.replace(/\\/g, "/");
+  if (
+    !relativePath ||
+    relativePath.startsWith("/") ||
+    relativePath.split("/").some((part) => part === "." || part === "..")
+  ) {
+    throw new Error(
+      "Local source file identity requires a safe relative path.",
+    );
+  }
+  return { ...input, relativePath };
+}
+
 export function localFolderSourceId(databaseId: string, connectionId: string) {
   return `content_database_source_local_folder_${createHash("sha256")
     .update(`${databaseId}:${connectionId}`)
@@ -14,7 +181,9 @@ export function localFolderSourceId(databaseId: string, connectionId: string) {
     .slice(0, 32)}`;
 }
 
-export function localFolderSourceCapabilities(): ContentDatabaseSourceCapabilities {
+export function localFolderSourceCapabilities(input?: {
+  liveBridgeEnabled?: boolean;
+}): ContentDatabaseSourceCapabilities {
   return {
     canRefresh: true,
     canCreateChangeSets: true,
@@ -25,7 +194,7 @@ export function localFolderSourceCapabilities(): ContentDatabaseSourceCapabiliti
     canPublish: false,
     canDelete: true,
     canStageLocalRevision: true,
-    liveWritesEnabled: false,
+    liveWritesEnabled: input?.liveBridgeEnabled === true,
     readOnlyRefresh: false,
     canRename: true,
     canReveal: true,
@@ -37,7 +206,16 @@ export function localFolderSourceMetadata(input: {
   connectionId: string;
   label: string;
   truthPolicy: ContentDatabaseSourceTruthPolicy;
+  connectionMetadata?: LocalFolderSourceConnectionMetadata;
 }) {
+  const connectionMetadata = localFolderSourceConnectionMetadataSchema.parse(
+    input.connectionMetadata ?? {},
+  );
+  const identity = normalizeLocalFolderSourceIdentity({
+    connectionId: input.connectionId,
+    label: input.label,
+    connectionMetadata,
+  });
   return {
     primaryKey: "relative_path",
     naturalKeyField: "relative_path",
@@ -47,6 +225,12 @@ export function localFolderSourceMetadata(input: {
     connectionLabel: input.label,
     truthPolicy: input.truthPolicy,
     writeMode: "stage_only" as const,
+    syncPolicy:
+      connectionMetadata.liveBridgeEnabled === true
+        ? ("keep_in_sync" as const)
+        : ("manual" as const),
+    liveBridgeEnabled: connectionMetadata.liveBridgeEnabled === true,
+    localIdentity: identity,
     notes:
       "The trusted local bridge owns the folder handle or path; SQL stores only this opaque connection identity.",
   };

package/corpus/templates/content/actions/connect-local-folder-source.ts

@@ -17,6 +17,8 @@ import {
 } from "./_content-spaces.js";
 import {
   LOCAL_FOLDER_SOURCE_TYPE,
+  localFolderSourceConnectionMetadataSchema,
+  localFolderOpaqueIdentitySchema,
   localFolderSourceCapabilities,
   localFolderSourceId,
   localFolderSourceMetadata,
@@ -30,12 +32,15 @@ export default defineAction({
   description:
     "Connect an opaque trusted local-folder handle to a canonical Files database. The browser or Desktop bridge keeps the real handle/path; Content stores only safe connection metadata.",
   schema: z.object({
-    connectionId: z
-      .string()
-      .min(1)
-      .max(300)
-      .describe("Stable opaque ID from the trusted browser/Desktop registry"),
+    connectionId: localFolderOpaqueIdentitySchema.describe(
+      "Stable opaque ID from the trusted browser/Desktop registry",
+    ),
     label: z.string().min(1).max(200).describe("User-visible folder label"),
+    connectionMetadata: localFolderSourceConnectionMetadataSchema
+      .optional()
+      .describe(
+        "Safe repository/working-copy identity from the trusted local bridge; raw paths and handles are not accepted.",
+      ),
     spaceId: z
       .string()
       .optional()
@@ -70,9 +75,10 @@ export default defineAction({
     }
 
     const db = getDb();
-    const connectionId = args.connectionId.trim();
+    const connectionId = args.connectionId;
     const label = args.label.trim();
     const truthPolicy = args.truthPolicy as ContentDatabaseSourceTruthPolicy;
+    const connectionMetadata = args.connectionMetadata;
     if (args.dryRun) {
       const [existing] = await db
         .select({
@@ -185,9 +191,18 @@ export default defineAction({
       sourceTable: connectionId,
       syncState: "linked",
       freshness: "unknown",
-      capabilitiesJson: JSON.stringify(localFolderSourceCapabilities()),
+      capabilitiesJson: JSON.stringify(
+        localFolderSourceCapabilities({
+          liveBridgeEnabled: connectionMetadata?.liveBridgeEnabled,
+        }),
+      ),
       metadataJson: JSON.stringify(
-        localFolderSourceMetadata({ connectionId, label, truthPolicy }),
+        localFolderSourceMetadata({
+          connectionId,
+          label,
+          truthPolicy,
+          connectionMetadata,
+        }),
       ),
       lastError: null,
       createdAt: now,

package/corpus/templates/content/actions/disconnect-local-folder-source.ts

@@ -80,7 +80,7 @@ export default defineAction({
         documentId: string;
         sourceDisplayKey: string | null;
         sourceValuesJson: string | null;
-        sourceName: string;
+        sourceTable: string;
       };
       const remainingLocalRows: RemainingLocalRow[] = documentIds.length
         ? await tx
@@ -90,7 +90,7 @@ export default defineAction({
                 schema.contentDatabaseSourceRows.sourceDisplayKey,
               sourceValuesJson:
                 schema.contentDatabaseSourceRows.sourceValuesJson,
-              sourceName: schema.contentDatabaseSources.sourceName,
+              sourceTable: schema.contentDatabaseSources.sourceTable,
             })
             .from(schema.contentDatabaseSourceRows)
             .innerJoin(
@@ -152,7 +152,7 @@ export default defineAction({
             sourceMode: "local-files",
             sourceKind: "file",
             sourcePath: relativePath,
-            sourceRootPath: remaining.sourceName,
+            sourceRootPath: remaining.sourceTable,
             sourceUpdatedAt: now,
             updatedAt: now,
           })

package/corpus/templates/content/actions/resolve-local-folder-conflict.ts

@@ -227,7 +227,7 @@ export default defineAction({
           .select({
             sourceDisplayKey: schema.contentDatabaseSourceRows.sourceDisplayKey,
             sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
-            sourceName: schema.contentDatabaseSources.sourceName,
+            sourceTable: schema.contentDatabaseSources.sourceTable,
           })
           .from(schema.contentDatabaseSourceRows)
           .innerJoin(
@@ -267,7 +267,7 @@ export default defineAction({
                   sourceMode: "local-files",
                   sourceKind: "file",
                   sourcePath: remainingPath ?? null,
-                  sourceRootPath: remainingLocalRow.sourceName,
+                  sourceRootPath: remainingLocalRow.sourceTable,
                   sourceUpdatedAt: now,
                   updatedAt: now,
                 }