@agent-native/core 0.84.20 → 0.84.22

package/corpus/templates/clips/shared/finalize-recovery.ts

@@ -0,0 +1,242 @@
+type FetchLike = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
+
+export type RecoveredReadyRecording = {
+  ok: true;
+  finalized: true;
+  recoveredAfterFinalizeError: true;
+  id: string;
+  recordingId: string;
+  status: "ready";
+  videoUrl: string;
+  durationMs?: number;
+  width?: number;
+  height?: number;
+  hasAudio?: boolean;
+  hasCamera?: boolean;
+};
+
+type ProbeResult =
+  | { ready: true; result: RecoveredReadyRecording }
+  | { ready: false; terminal: boolean; status?: string };
+
+const DEFAULT_READY_RECOVERY_TIMEOUT_MS = 90_000;
+const DEFAULT_READY_RECOVERY_INTERVAL_MS = 3_000;
+const DEFAULT_READY_RECOVERY_FETCH_TIMEOUT_MS = 2_000;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function absoluteUploadUrl(uploadUrl: string): URL {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(uploadUrl)) return new URL(uploadUrl);
+  const origin =
+    typeof globalThis.location?.origin === "string"
+      ? globalThis.location.origin
+      : "http://localhost";
+  return new URL(uploadUrl, origin);
+}
+
+function maybeRelativeUrl(url: URL, original: string): string {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(original)) return url.toString();
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+
+export function publicRecordingStatusUrl(
+  uploadUrl: string,
+  recordingId: string,
+): string {
+  const url = absoluteUploadUrl(uploadUrl);
+  const match = url.pathname.match(/^(.*)\/api\/uploads\/[^/]+\/chunk$/);
+  const basePath = match?.[1] ?? "";
+  url.pathname = `${basePath}/api/public-recording`;
+  url.search = "";
+  url.searchParams.set("id", recordingId);
+  return maybeRelativeUrl(url, uploadUrl);
+}
+
+export function authenticatedRecordingStatusUrl(
+  uploadUrl: string,
+  recordingId: string,
+): string {
+  const url = absoluteUploadUrl(uploadUrl);
+  const match = url.pathname.match(/^(.*)\/api\/uploads\/[^/]+\/chunk$/);
+  const basePath = match?.[1] ?? "";
+  url.pathname = `${basePath}/api/uploads/${encodeURIComponent(
+    recordingId,
+  )}/status`;
+  url.search = "";
+  return maybeRelativeUrl(url, uploadUrl);
+}
+
+function optionalNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
+}
+
+function optionalBoolean(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
+export function readyRecordingFromPublicPayload(
+  payload: unknown,
+  fallbackRecordingId: string,
+): ProbeResult {
+  const root =
+    payload && typeof payload === "object"
+      ? (payload as Record<string, unknown>)
+      : null;
+  const recording =
+    root?.recording && typeof root.recording === "object"
+      ? (root.recording as Record<string, unknown>)
+      : null;
+  const status =
+    typeof recording?.status === "string" ? recording.status : undefined;
+
+  if (!recording) return { ready: false, terminal: false };
+  if (status === "failed") return { ready: false, terminal: true, status };
+
+  const videoUrl =
+    typeof recording.videoUrl === "string" ? recording.videoUrl : "";
+  if (status !== "ready" || !videoUrl) {
+    return { ready: false, terminal: false, status };
+  }
+
+  const id =
+    typeof recording.id === "string" && recording.id
+      ? recording.id
+      : fallbackRecordingId;
+  return {
+    ready: true,
+    result: {
+      ok: true,
+      finalized: true,
+      recoveredAfterFinalizeError: true,
+      id,
+      recordingId: id,
+      status: "ready",
+      videoUrl,
+      durationMs: optionalNumber(recording.durationMs),
+      width: optionalNumber(recording.width),
+      height: optionalNumber(recording.height),
+      hasAudio: optionalBoolean(recording.hasAudio),
+      hasCamera: optionalBoolean(recording.hasCamera),
+    },
+  };
+}
+
+async function fetchWithTimeout(
+  fetchImpl: FetchLike,
+  url: string,
+  init: RequestInit,
+  timeoutMs: number,
+): Promise<Response> {
+  if (timeoutMs <= 0 || typeof AbortController === "undefined") {
+    return fetchImpl(url, init);
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetchImpl(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function waitForReadyRecordingAfterFinalizeError(args: {
+  uploadUrl: string;
+  recordingId: string;
+  authToken?: string | null;
+  preferAuthenticated?: boolean;
+  fetchImpl?: FetchLike;
+  sleepImpl?: (ms: number) => Promise<void>;
+  timeoutMs?: number;
+  intervalMs?: number;
+  fetchTimeoutMs?: number;
+}): Promise<RecoveredReadyRecording | null> {
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const sleepImpl = args.sleepImpl ?? sleep;
+  const timeoutMs = Math.max(
+    1,
+    args.timeoutMs ?? DEFAULT_READY_RECOVERY_TIMEOUT_MS,
+  );
+  const intervalMs = Math.max(
+    1,
+    args.intervalMs ?? DEFAULT_READY_RECOVERY_INTERVAL_MS,
+  );
+  const attempts = Math.max(1, Math.ceil(timeoutMs / intervalMs));
+  let url: string;
+  let authenticatedUrl: string | null = null;
+  try {
+    url = publicRecordingStatusUrl(args.uploadUrl, args.recordingId);
+    authenticatedUrl =
+      args.authToken || args.preferAuthenticated
+        ? authenticatedRecordingStatusUrl(args.uploadUrl, args.recordingId)
+        : null;
+  } catch {
+    return null;
+  }
+
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const urls = authenticatedUrl
+      ? [
+          { url: authenticatedUrl, authenticated: true },
+          { url, authenticated: false },
+        ]
+      : [{ url, authenticated: false }];
+
+    for (const endpoint of urls) {
+      const headers: Record<string, string> = {
+        Accept: "application/json",
+        "X-Agent-Native-Frontend": "1",
+      };
+      if (endpoint.authenticated && args.authToken) {
+        headers.Authorization = `Bearer ${args.authToken}`;
+      }
+
+      try {
+        const response = await fetchWithTimeout(
+          fetchImpl,
+          endpoint.url,
+          {
+            method: "GET",
+            headers,
+            credentials: "include",
+            cache: "no-store",
+          },
+          args.fetchTimeoutMs ?? DEFAULT_READY_RECOVERY_FETCH_TIMEOUT_MS,
+        );
+
+        if (response.ok) {
+          const payload = await response.json().catch(() => null);
+          const probe = readyRecordingFromPublicPayload(
+            payload,
+            args.recordingId,
+          );
+          if (probe.ready) return probe.result;
+          if (probe.terminal) return null;
+          break;
+        }
+
+        if (
+          response.status >= 400 &&
+          response.status < 500 &&
+          !endpoint.authenticated &&
+          !authenticatedUrl
+        ) {
+          return null;
+        }
+      } catch {
+        // Try the public endpoint fallback below, then keep polling.
+      }
+    }
+
+    if (attempt < attempts - 1) await sleepImpl(intervalMs);
+  }
+
+  return null;
+}

package/corpus/templates/content/AGENTS.md

@@ -108,7 +108,10 @@ cd templates/content && pnpm action <name> [args]
 | `list-local-component-files`                |                                                                                                                                                                | List registered local MDX component source files                                                                                        |
 | `write-local-component-file`                | `--workspaceId <id> --path <relative-component-path> --content <source>`                                                                                       | Create or update a file in a registered local `components/` folder                                                                      |
 | `create-content-database`                   | `[--documentId <id>] [--parentId <id>] [--title <text>]`                                                                                                       | Create a database page or convert an existing page into a database                                                                      |
+| `create-inline-content-database`            | `--hostDocumentId <id> [--title <text>]`                                                                                                                       | Create a database owned by an inline database block in the host document                                                                |
 | `get-content-database`                      | `--databaseId <id>` or `--documentId <id>`                                                                                                                     | Get a database table with property schema and item pages                                                                                |
+| `list-trashed-content-databases`            |                                                                                                                                                                | List soft-deleted databases visible in the sidebar Trash surface                                                                        |
+| `restore-content-database`                  | `--databaseId <id>`                                                                                                                                            | Restore a soft-deleted database from the sidebar Trash surface                                                                          |
 | `get-content-database-source`               | `--databaseId <id>` or `--documentId <id>`                                                                                                                     | Inspect local/no-source or source-backed status, mappings, row identity, freshness, and change sets                                     |
 | `attach-content-database-source`            | `--databaseId <id>` or `--documentId <id> [--sourceType mock\|builder-cms] [--sourceName] [--sourceTable] [--relationshipMode items\|details] [--join <json>]` | Attach a source binding; use `items` to add more rows and `details` to match a source onto existing rows                                |
 | `change-content-database-source-role`       | `--databaseId <id>` or `--documentId <id> --sourceId <id> --relationshipMode items\|details [--join <json>]`                                                   | Change an attached source between adding rows and adding matched detail columns without removing the source                             |
@@ -569,9 +572,10 @@ columns updates that row page's grouping property through
 multi-select, users can add a new board group from the board itself; this
 appends a new option to the grouped property definition.
 Use
-`create-content-database`, `get-content-database`,
-`add-database-item`, `duplicate-database-item`, `duplicate-database-items`,
-`delete-database-items`, `move-database-item`,
+`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`,
 `update-content-database-view`, `list-document-properties`,
 `configure-document-property`, `set-document-property`,
 `duplicate-document-property`, and `delete-document-property`; do not edit

package/corpus/templates/content/README.md

@@ -1,46 +1,34 @@
 # Content
 
-Open-source Obsidian for MDX, built with the agent-native framework. Edit local
-Markdown/MDX files, generate rich interactive custom blocks, and organize
-hierarchical pages with an AI agent.
+Open-source Obsidian for MDX — an agent-native, local-file document workspace and
+a self-hostable alternative to Notion and Obsidian. Edit local Markdown/MDX files,
+build Notion-style databases, and write with an AI agent.
+
+**Live app: [content.agent-native.com](https://content.agent-native.com)**
+
+Open a doc and ask "rewrite this paragraph to be more concise" or "create a page
+called Q4 Planning with sub-pages for Goals, Metrics, and Risks" — the same result
+whether you do it yourself or ask. Documents can live in your SQL database or as
+local Markdown/MDX files.
 
 ## Features
 
-- Hierarchical pages (unlimited nesting)
-- Rich text editor (Tiptap) with slash commands
-- Favorites for quick access
-- Full-text search
-- Local Markdown/MDX file editing
-- Custom interactive MDX blocks from local components
-- Agent can create, read, update, and search documents
-- Auto-save with debouncing
-- Dark/light theme
+- Rich-text editor (Tiptap) with slash commands and hierarchical pages.
+- Notion-style databases with table, board, calendar, gallery, and timeline views.
+- Local Markdown/MDX file editing plus custom interactive MDX components.
+- Inline comments, version history, and full-text search.
+- Private-by-default sharing with per-user / per-org grants and public pages.
+- Optional Notion and Builder.io sync.
 
-## Getting Started
+## Develop locally
+
+Scaffold your own copy and run it:
 
 ```bash
+npx @agent-native/core@latest create my-content --standalone --template content
+cd my-content
 pnpm install
 pnpm dev
 ```
 
-Open http://localhost:8080 and create your first page.
-
-## Data
-
-Documents are stored in the app's SQL database. Local development defaults to SQLite at `data/app.db`; deployed apps should set `DATABASE_URL` to a persistent SQL database. The agent should use content actions for normal document operations and reserve `db-query` / `db-exec` for inspection or maintenance.
-
-## Enable Builder live writes
-
-Connect Builder through the existing Builder Connect flow, the same connection used by the AI assistant. Once connected, Content resolves the key automatically for the user, or for org owners/admins through the org connection. There is no separate key entry. In local development, `BUILDER_PRIVATE_KEY` and `BUILDER_PUBLIC_KEY` in `.env.local` also work; see `DEVELOPING.md` for local env opt-in details.
-
-Live writes are only allowed for the safe write model `agent-native-blog-article-test` (`BUILDER_CMS_SAFE_WRITE_MODEL`). Other Builder models stay read-only by design.
-
-Write access is an intentional per-source choice from the source panel selector. Sources start at `read_only`, can move to `stage_only` to push approved changes as Builder autosave revisions, and can move to `publish_updates` for state-preserving live writes. Autosave staging stays quiet; update-in-place and publish writes trigger Builder webhooks so downstream rebuilds can run.
-
-In `publish_updates`, Content PATCHes the Builder entry in place and preserves its current publication state: published entries stay published and drafts stay draft. Content never sends a `published` field, so a normal content push cannot publish or unpublish. Builder merges the field changes and preserves the entry envelope, including scheduling and targeting.
-
-Publication transitions are explicit per-row choices in the review/diff, only when the source enables **Allow publish/unpublish per item**. Publishing a draft or unpublishing a published entry is never a bulk default, and unpublish requires confirmation because it takes live content down. New Builder entries are created as drafts.
-
-**Push all approved (N)** runs approved rows in a concurrency-capped batch. It continues after individual errors, reports per-item `succeeded`, `blocked`, or `failed` status, and can be resumed because already-succeeded items are skipped.
-
-Before each write, Content reads the target's current state from Builder. A write blocks if the entry changed or was deleted since the diff, or if a requested publish/unpublish transition no longer matches the real Builder state. Body diffs remain non-executable for now; they are planned for a later slice.
+Full docs: [agent-native.com/docs/template-content](https://agent-native.com/docs/template-content).

package/corpus/templates/content/actions/list-trashed-content-databases.ts

@@ -33,6 +33,7 @@ export default defineAction({
         ownerDocumentId: schema.contentDatabases.ownerDocumentId,
         deletedAt: schema.contentDatabases.deletedAt,
         documentTitle: schema.documents.title,
+        documentParentId: schema.documents.parentId,
       })
       .from(schema.contentDatabases)
       .innerJoin(
@@ -80,6 +81,9 @@ export default defineAction({
         documentId: row.documentId,
         ownerDocumentId: row.ownerDocumentId,
         deletedAt: row.deletedAt!,
+        canPermanentlyDelete:
+          row.ownerDocumentId === null ||
+          row.documentParentId !== row.ownerDocumentId,
       })),
     };
   },

package/corpus/templates/content/app/components/editor/SlashCommandMenu.tsx

@@ -1,5 +1,7 @@
 import { useSendToAgentChat, useT } from "@agent-native/core/client";
+import type { CreateInlineDatabaseResponse } from "@shared/api";
 import { collapseExactRepeatedNfm, docToNfm } from "@shared/nfm";
+import { serializeRegistryBlockToMdx } from "@shared/nfm-registry";
 import {
   IconTypography,
   IconH1,
@@ -33,7 +35,7 @@ import {
   PopoverContent,
   PopoverTrigger,
 } from "@/components/ui/popover";
-import { useCreateContentDatabase } from "@/hooks/use-content-database";
+import { useCreateInlineContentDatabase } from "@/hooks/use-content-database";
 import { useCreatePage } from "@/hooks/use-create-page";
 import { cn } from "@/lib/utils";
 import { localContentComponents } from "@/local-components";
@@ -146,6 +148,36 @@ export function parseSlashCommandQuery(textBeforeCursor: string) {
   return textBeforeCursor.match(/^\s*\/([a-zA-Z0-9]*)$/)?.[1] ?? null;
 }
 
+export function inlineDatabaseBlockContent(
+  block: CreateInlineDatabaseResponse["block"],
+) {
+  return {
+    type: "registryBlock",
+    attrs: {
+      blockType: "inline-database",
+      blockId: block.ownerBlockId,
+      title: null,
+      summary: null,
+      __raw: serializeRegistryBlockToMdx("inline-database", {
+        id: block.ownerBlockId,
+        data: block,
+      }),
+    },
+  };
+}
+
+export function insertInlineDatabaseBlock(
+  editor: Editor,
+  block: CreateInlineDatabaseResponse["block"],
+  position?: number | { from: number; to: number } | null,
+) {
+  const content = inlineDatabaseBlockContent(block);
+  const chain = editor.chain().focus();
+  return position != null
+    ? chain.insertContentAt(position, content).run()
+    : chain.insertContent(content).run();
+}
+
 const commands: CommandTemplate[] = [
   {
     titleKey: "editor.slash.text",
@@ -407,7 +439,9 @@ export function SlashCommandMenu({
   const { send } = useSendToAgentChat();
   const navigate = useNavigate();
   const createPage = useCreatePage({ navigate: false, awaitPersist: true });
-  const createDatabase = useCreateContentDatabase(documentId ?? null);
+  const createInlineDatabase = useCreateInlineContentDatabase(
+    documentId ?? null,
+  );
 
   const [isOpen, setIsOpen] = useState(false);
   const [isTurnInto, setIsTurnInto] = useState(false);
@@ -609,18 +643,36 @@ export function SlashCommandMenu({
     title: t("editor.slash.database"),
     description: t("editor.slash.databaseDescription"),
     icon: IconDatabase,
-    action: async () => {
+    preserveSlashRange: true,
+    action: async (editor, { slashRange }) => {
       if (!documentId) {
         toast.error(t("editor.noDocumentSelected"));
         return;
       }
+      if (slashRange) {
+        editor.chain().focus().deleteRange(slashRange).run();
+      }
       const toastId = toast.loading(t("editor.creatingDatabase"));
       try {
-        const result = await createDatabase.mutateAsync({
-          parentId: documentId,
+        const result = await createInlineDatabase.mutateAsync({
+          hostDocumentId: documentId,
           title: t("editor.untitledDatabase"),
         });
-        navigate(`/page/${result.database.documentId}`, { flushSync: true });
+        const inserted = insertInlineDatabaseBlock(editor, result.block);
+        if (!inserted) throw new Error(t("empty.genericError"));
+        await waitForEditorUpdateFrame();
+        const content = collapseExactRepeatedNfm(
+          docToNfm(editor.getJSON() as any),
+          {
+            requiredText: result.block.ownerBlockId,
+          },
+        );
+        if (onDraftPersisted) {
+          const persisted = await onDraftPersisted(content);
+          if (!persisted) throw new Error(t("empty.genericError"));
+        } else {
+          await onDraftCommitted?.();
+        }
         toast.success(t("editor.databaseCreated"), { id: toastId });
       } catch (error) {
         toast.error(t("editor.failedToCreateDatabase"), {