@agent-native/core 0.86.0 → 0.86.1

package/corpus/core/src/client/db-admin/TableEditor.tsx

@@ -36,11 +36,17 @@ import { DataGrid, type GridRow, type ActiveCell } from "./DataGrid.js";
 import { FilterBar } from "./FilterBar.js";
 import { RowSidePanel, type RowSidePanelMode } from "./RowSidePanel.js";
 import { loadGridState, saveGridState } from "./storage.js";
-import { useTableSchema, useTableRows, mutateTable } from "./useDbAdmin.js";
+import {
+  useTableSchema,
+  useTableRows,
+  mutateTable,
+  type DbAdminRequestConfig,
+} from "./useDbAdmin.js";
 
 export interface TableEditorProps {
   table: string;
   dialect: DbAdminDialect;
+  requestConfig?: DbAdminRequestConfig;
   initialFilters?: DbAdminFilter[];
   onNavigateToRow: (table: string, filters: DbAdminFilter[]) => void;
 }
@@ -51,6 +57,7 @@ const PAGE_SIZES = [25, 50, 100, 250, 500];
 export function TableEditor({
   table,
   dialect: _dialect,
+  requestConfig,
   initialFilters,
   onNavigateToRow,
 }: TableEditorProps) {
@@ -90,12 +97,12 @@ export function TableEditor({
   }, [table, columnWidths, sort, filters, pageSize]);
 
   // ─── Data ────────────────────────────────────────────────────────────────
-  const schemaState = useTableSchema(table);
+  const schemaState = useTableSchema(table, requestConfig);
   const rowsReq = useMemo(
     () => ({ page, pageSize, sort, filters }),
     [page, pageSize, sort, filters],
   );
-  const rowsState = useTableRows(table, rowsReq);
+  const rowsState = useTableRows(table, rowsReq, requestConfig);
 
   const schema = schemaState.data;
   const changeset = useChangeset(schema);
@@ -201,9 +208,9 @@ export function TableEditor({
       if (!mutation.inserts && !mutation.updates && !mutation.deletes) {
         return null;
       }
-      return mutateTable(table, mutation);
+      return mutateTable(table, mutation, requestConfig);
     },
-    [changeset, originalRows, table],
+    [changeset, originalRows, requestConfig, table],
   );
 
   const handlePreview = useCallback(async () => {

package/corpus/core/src/client/db-admin/useAgentSync.ts

@@ -64,6 +64,7 @@ export interface DbAdminNavigationState {
 export interface UseDbAdminAgentSyncArgs {
   table: string | null;
   mode: "table" | "sql";
+  enabled?: boolean;
 }
 
 /**
@@ -74,8 +75,10 @@ export interface UseDbAdminAgentSyncArgs {
 export function useDbAdminAgentSync({
   table,
   mode,
+  enabled = true,
 }: UseDbAdminAgentSyncArgs): void {
   useEffect(() => {
+    if (!enabled) return;
     const state: DbAdminNavigationState = { view: "database", table, mode };
     fetch(NAVIGATION_PATH, {
       method: "PUT",
@@ -84,7 +87,7 @@ export function useDbAdminAgentSync({
       headers: headers({ "Content-Type": "application/json" }),
       body: JSON.stringify(state),
     }).catch(() => {});
-  }, [table, mode]);
+  }, [enabled, table, mode]);
 }
 
 interface NavigateCommand {
@@ -97,11 +100,15 @@ interface NavigateCommand {
  * a database table, invoke `onNavigate(table)` then clear the key so it does
  * not replay on the next poll.
  */
-export function useNavigateConsumer(onNavigate: (table: string) => void): void {
+export function useNavigateConsumer(
+  onNavigate: (table: string) => void,
+  enabled = true,
+): void {
   const handlerRef = useRef(onNavigate);
   handlerRef.current = onNavigate;
 
   useEffect(() => {
+    if (!enabled) return;
     let active = true;
     let timer: ReturnType<typeof setTimeout> | undefined;
 
@@ -143,5 +150,5 @@ export function useNavigateConsumer(onNavigate: (table: string) => void): void {
       active = false;
       if (timer) clearTimeout(timer);
     };
-  }, []);
+  }, [enabled]);
 }

package/corpus/core/src/client/db-admin/useDbAdmin.ts

@@ -34,6 +34,19 @@ import { useChangeVersions } from "../use-change-version.js";
 
 export const dbAdminBasePath = agentNativePath("/_agent-native/db-admin");
 
+export interface DbAdminRequestConfig {
+  basePath?: string;
+  scopeKey?: string;
+}
+
+function requestBasePath(config?: DbAdminRequestConfig): string {
+  return (config?.basePath ?? dbAdminBasePath).replace(/\/+$/, "");
+}
+
+function requestScopeKey(config?: DbAdminRequestConfig): string {
+  return config?.scopeKey ?? requestBasePath(config);
+}
+
 // ─── Tab id (request source) ───────────────────────────────────────────────
 
 let cachedTabId: string | null = null;
@@ -104,8 +117,11 @@ async function parseEnvelope<T>(res: Response): Promise<T> {
   return json;
 }
 
-export async function dbAdminGet<T>(subpath: string): Promise<T> {
-  const res = await fetch(`${dbAdminBasePath}${subpath}`, {
+export async function dbAdminGet<T>(
+  subpath: string,
+  config?: DbAdminRequestConfig,
+): Promise<T> {
+  const res = await fetch(`${requestBasePath(config)}${subpath}`, {
     method: "GET",
     credentials: "include",
     headers: baseHeaders(),
@@ -116,8 +132,9 @@ export async function dbAdminGet<T>(subpath: string): Promise<T> {
 export async function dbAdminPost<T>(
   subpath: string,
   body: unknown,
+  config?: DbAdminRequestConfig,
 ): Promise<T> {
-  const res = await fetch(`${dbAdminBasePath}${subpath}`, {
+  const res = await fetch(`${requestBasePath(config)}${subpath}`, {
     method: "POST",
     credentials: "include",
     headers: baseHeaders({ "Content-Type": "application/json" }),
@@ -159,12 +176,18 @@ interface OverviewResponse {
   tables: DbAdminTableSummary[];
 }
 
-export function useOverview(): DbAdminQueryState<DbAdminOverview> {
-  const version = useChangeVersions(["db-admin", "action"]);
+export function useOverview(
+  config?: DbAdminRequestConfig,
+): DbAdminQueryState<DbAdminOverview> {
+  const version = useChangeVersions([
+    "db-admin",
+    "analytics-db-admin",
+    "action",
+  ]);
   const query = useQuery<DbAdminOverview, Error>({
-    queryKey: ["db-admin", "overview", version],
+    queryKey: ["db-admin", requestScopeKey(config), "overview", version],
     queryFn: async () => {
-      const res = await dbAdminGet<OverviewResponse>("/overview");
+      const res = await dbAdminGet<OverviewResponse>("/overview", config);
       return { dialect: res.dialect, tables: res.tables };
     },
     placeholderData: keepPreviousData,
@@ -182,14 +205,20 @@ interface SchemaResponse {
 
 export function useTableSchema(
   table: string | null,
+  config?: DbAdminRequestConfig,
 ): DbAdminQueryState<DbAdminTableSchema> {
-  const version = useChangeVersions(["db-admin", "action"]);
+  const version = useChangeVersions([
+    "db-admin",
+    "analytics-db-admin",
+    "action",
+  ]);
   const query = useQuery<DbAdminTableSchema, Error>({
-    queryKey: ["db-admin", "schema", table, version],
+    queryKey: ["db-admin", requestScopeKey(config), "schema", table, version],
     enabled: !!table,
     queryFn: async () => {
       const res = await dbAdminGet<SchemaResponse>(
         `/table/${encodeURIComponent(table!)}/schema`,
+        config,
       );
       return res.table;
     },
@@ -204,15 +233,28 @@ export function useTableSchema(
 export function useTableRows(
   table: string | null,
   req: DbAdminRowsRequest,
+  config?: DbAdminRequestConfig,
 ): DbAdminQueryState<DbAdminRowsResult> {
-  const version = useChangeVersions(["db-admin", "action"]);
+  const version = useChangeVersions([
+    "db-admin",
+    "analytics-db-admin",
+    "action",
+  ]);
   const query = useQuery<DbAdminRowsResult, Error>({
-    queryKey: ["db-admin", "rows", table, req, version],
+    queryKey: [
+      "db-admin",
+      requestScopeKey(config),
+      "rows",
+      table,
+      req,
+      version,
+    ],
     enabled: !!table,
     queryFn: () =>
       dbAdminPost<DbAdminRowsResult>(
         `/table/${encodeURIComponent(table!)}/rows`,
         req,
+        config,
       ),
     placeholderData: keepPreviousData,
     staleTime: 2000,
@@ -225,10 +267,12 @@ export function useTableRows(
 export async function mutateTable(
   table: string,
   mutation: DbAdminMutation,
+  config?: DbAdminRequestConfig,
 ): Promise<DbAdminMutationResult> {
   return dbAdminPost<DbAdminMutationResult>(
     `/table/${encodeURIComponent(table)}/mutate`,
     mutation,
+    config,
   );
 }
 
@@ -236,10 +280,15 @@ export async function runQuery(
   sql: string,
   params?: unknown[],
   confirmDestructive?: boolean,
+  config?: DbAdminRequestConfig,
 ): Promise<DbAdminQueryResult> {
-  return dbAdminPost<DbAdminQueryResult>("/query", {
-    sql,
-    params,
-    confirmDestructive,
-  });
+  return dbAdminPost<DbAdminQueryResult>(
+    "/query",
+    {
+      sql,
+      params,
+      confirmDestructive,
+    },
+    config,
+  );
 }

package/corpus/core/src/client/error-reporting.ts

@@ -0,0 +1,100 @@
+import {
+  getFeedbackClientContext,
+  type FeedbackClientContext,
+  type FeedbackClientContextOptions,
+} from "./feedback-context.js";
+
+const GITHUB_ISSUE_URL = "https://github.com/BuilderIO/agent-native/issues/new";
+
+export interface ErrorReportDebugItem {
+  label: string;
+  value?: unknown;
+}
+
+export interface ErrorReportTemplateOptions {
+  title?: string | null;
+  details?: string | null;
+  status?: number | string | null;
+  appName?: string | null;
+  prompt?: string;
+  issueTitle?: string;
+  feedbackContext?: FeedbackClientContext;
+  contextOptions?: FeedbackClientContextOptions;
+  extraDebug?: ErrorReportDebugItem[];
+}
+
+function cleanText(value: unknown): string | null {
+  if (value === null || value === undefined) return null;
+  const text = String(value).trim();
+  return text ? text : null;
+}
+
+function resolveContext(
+  options: ErrorReportTemplateOptions,
+): FeedbackClientContext {
+  return (
+    options.feedbackContext ?? getFeedbackClientContext(options.contextOptions)
+  );
+}
+
+function debugLines(options: ErrorReportTemplateOptions): string[] {
+  const context = resolveContext(options);
+  const lines: string[] = [];
+  const appName = cleanText(options.appName);
+  const title = cleanText(options.title);
+  const details = cleanText(options.details);
+  const status = cleanText(options.status);
+
+  if (appName) lines.push(`App: ${appName}`);
+  if (status) lines.push(`Status: ${status}`);
+  if (title) lines.push(`Screen: ${title}`);
+  if (details && details !== title) lines.push(`Error: ${details}`);
+  if (context.pageUrl) lines.push(`Page: ${context.pageUrl}`);
+  if (context.clientSurface) lines.push(`Source: ${context.clientSurface}`);
+  if (context.activeRunId) lines.push(`Run: ${context.activeRunId}`);
+  if (context.chatSessionIds.length === 1) {
+    lines.push(`Chat session: ${context.chatSessionIds[0]}`);
+  } else if (context.chatSessionIds.length > 1) {
+    lines.push(`Chat sessions: ${context.chatSessionIds.join(", ")}`);
+  }
+  for (const item of options.extraDebug ?? []) {
+    const value = cleanText(item.value);
+    if (value) lines.push(`${item.label}: ${value}`);
+  }
+  return lines;
+}
+
+export function buildErrorReportTemplate(
+  options: ErrorReportTemplateOptions,
+): string {
+  const lines = debugLines(options);
+  return [
+    options.prompt ?? "Describe what happened here:",
+    "",
+    "",
+    "---",
+    "Debug info:",
+    ...(lines.length ? lines : ["No client debug info available."]),
+  ].join("\n");
+}
+
+export function buildGitHubIssueUrl(
+  options: ErrorReportTemplateOptions,
+): string {
+  const title =
+    cleanText(options.issueTitle) ??
+    [
+      cleanText(options.appName) ?? "Agent Native",
+      cleanText(options.title) ?? "Error screen",
+    ].join(": ");
+  const url = new URL(GITHUB_ISSUE_URL);
+  url.searchParams.set("title", title.slice(0, 180));
+  url.searchParams.set(
+    "body",
+    buildErrorReportTemplate({
+      ...options,
+      prompt: options.prompt ?? "Describe your issue here:",
+    }),
+  );
+  return url.toString();
+}

package/corpus/core/src/client/index.ts

@@ -165,6 +165,7 @@ export {
 } from "./use-db-sync.js";
 export {
   VisualControlRow,
+  VisualColorPicker,
   VisualInspectorPanel,
   VisualInspectorSection,
   VisualScrubInput,
@@ -669,6 +670,16 @@ export {
   type StarfieldBackgroundProps,
 } from "./StarfieldBackground.js";
 export { FeedbackButton, type FeedbackButtonProps } from "./FeedbackButton.js";
+export {
+  ErrorReportActions,
+  type ErrorReportActionsProps,
+} from "./ErrorReportActions.js";
+export {
+  buildErrorReportTemplate,
+  buildGitHubIssueUrl,
+  type ErrorReportDebugItem,
+  type ErrorReportTemplateOptions,
+} from "./error-reporting.js";
 export { getClientSurface, type ClientSurface } from "./client-surface.js";
 export {
   DevDatabaseLink,

package/corpus/core/src/client/org/RequireActiveOrg.tsx

@@ -7,6 +7,7 @@ import {
 } from "@tabler/icons-react";
 import { ReactNode, useState } from "react";
 
+import { ErrorReportActions } from "../ErrorReportActions.js";
 import { useT } from "../i18n.js";
 import {
   useAcceptInvitation,
@@ -115,6 +116,17 @@ function ErrorPane({
         >
           {t("org.tryAgain")}
         </button>
+        <ErrorReportActions
+          appName="Organization"
+          title={t("org.loadErrorTitle")}
+          details={message}
+          issueTitle="Organization load error"
+          feedbackLabel={t("org.sendFeedback")}
+          feedbackPlaceholder={t("org.feedbackPlaceholder")}
+          githubLabel={t("org.openGitHubIssue")}
+          className="mt-4 justify-start"
+          align="start"
+        />
       </div>
     </div>
   );