@agent-native/core 0.103.1 → 0.104.0

package/corpus/core/src/extensions/actions.ts

@@ -1,5 +1,5 @@
 import { ACTION_CHAT_UI_INLINE_EXTENSION_RENDERER } from "../action-ui.js";
-import type { ActionRunContext } from "../action.js";
+import { AgentActionStopError, type ActionRunContext } from "../action.js";
 import type { ActionEntry } from "../agent/production-agent.js";
 import type { AgentChatAttachment } from "../agent/types.js";
 import { writeAppState } from "../application-state/script-helpers.js";
@@ -14,6 +14,7 @@ import {
   readWorkspaceFile,
   type WorkspaceFilesScope,
 } from "../workspace-files/store.js";
+import { ExtensionContentEditError } from "./content-patch.js";
 import type {
   ExtensionContentEdit,
   ExtensionLegacyPatch,
@@ -617,7 +618,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
     "update-extension": {
       tool: {
         description:
-          'Update an existing sandboxed Alpine.js mini-app extension. If the user is viewing the extension, use the extensionId from <current-screen> or <current-url> directly; do not list extensions first just to find the current id. Prefer granular edits for surgical changes; use full content replacement only for broad rewrites. Supported edits include literal replace, insert-before/after marker, replace-between markers, replace-section/wrap-section/remove-section for <!-- agent-native:section name --> blocks, and regex-replace. Pass format=true to run Prettier on the final HTML. To replace the whole body with a large pasted file, pass contentFromAttachment (the attachment name, or "latest") instead of copying the file into `content` — that avoids re-emitting thousands of tokens.',
+          'Update an existing sandboxed Alpine.js mini-app extension. If the user is viewing the extension, use the extensionId from <current-screen> or <current-url> directly; do not list extensions first just to find the current id. Prefer granular edits for surgical changes; full-body replacement is blocked by default to preserve existing layout, CSS, copy, and interactions during data-only fixes. Use `patches` or `edits` for targeted changes; set `allowFullReplacement=true` only when the user explicitly asks for a visual rewrite or supplies a complete replacement body. Supported edits include literal replace, insert-before/after marker, replace-between markers, replace-section/wrap-section/remove-section for <!-- agent-native:section name --> blocks, and regex-replace. Pass format=true to run Prettier on the final HTML. To replace the whole body with a large pasted file, pass contentFromAttachment (the attachment name, or "latest") instead of copying the file into `content` — that avoids re-emitting thousands of tokens.',
         parameters: {
           type: "object",
           properties: {
@@ -649,15 +650,26 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
               description:
                 'Optional full replacement sourced from a workspace/shared resource file, by resource path (e.g. "intuit-analytics-extension.html"). The server reads the full file and uses it as the replacement body. Use instead of `content` when replacing the whole body with a large file that exists as a workspace resource. Ignored when `content` is provided.',
             },
+            allowFullReplacement: {
+              type: "boolean",
+              description:
+                "Explicitly allow replacing the entire existing body. Omit or set false for data-only repairs so the existing visual design is protected. Use true only when the user explicitly requested a broad visual rewrite or supplied a complete replacement body.",
+            },
             patches: {
-              type: "string",
+              anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "object" } },
+              ],
               description:
-                'Legacy optional JSON array of { "find": "...", "replace": "...", "all"?: true, "expectedMatches"?: 1, "required"?: true } patches. Missing required targets fail instead of silently no-oping.',
+                'Optional patches as a JSON-encoded string or native array of { "find": "...", "replace": "...", "all"?: true, "expectedMatches"?: 1, "required"?: true } objects. Missing required targets fail instead of silently no-oping.',
             },
             edits: {
-              type: "string",
+              anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "object" } },
+              ],
               description:
-                'Preferred optional JSON array of granular edit operations. Examples: { "op": "insert-after", "marker": "<!-- section:metrics -->", "content": "..." }, { "op": "replace-section", "section": "npm-chart", "content": "..." }, { "op": "wrap-section", "section": "charts", "before": "<div>", "after": "</div>" }, { "op": "regex-replace", "pattern": "...", "replace": "...", "expectedMatches": 1 }.',
+                'Preferred optional granular edit operations as a JSON-encoded string or native array. Examples: { "op": "insert-after", "marker": "<!-- section:metrics -->", "content": "..." }, { "op": "replace-section", "section": "npm-chart", "content": "..." }, { "op": "wrap-section", "section": "charts", "before": "<div>", "after": "</div>" }, { "op": "regex-replace", "pattern": "...", "replace": "...", "expectedMatches": 1 }.',
             },
             format: {
               type: "boolean",
@@ -670,8 +682,9 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
             },
             visibility: {
               type: "string",
-              description: "Optional sharing visibility.",
-              enum: ["private", "org", "public"],
+              description:
+                "Optional sharing visibility. Public extension sharing is not supported; use private or org.",
+              enum: ["private", "org"],
             },
           },
           required: ["id"],
@@ -683,6 +696,53 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
         const localMessage = await localExtensionEditMessage(id);
         if (localMessage) return localMessage;
 
+        if (
+          typeof args?.visibility === "string" &&
+          args.visibility.trim().toLowerCase() === "public"
+        ) {
+          const message =
+            "Public extension sharing is not supported. Use visibility=private or visibility=org. No content changes were applied; do not retry visibility=public.";
+          throw new AgentActionStopError(message, {
+            errorCode: "extension_public_visibility_unsupported",
+            toolResult: JSON.stringify(
+              {
+                error: "extension_public_visibility_unsupported",
+                message,
+                recoverable: false,
+                next: "Retry only with visibility=private or visibility=org.",
+              },
+              null,
+              2,
+            ),
+          });
+        }
+
+        const fullReplacementRequested =
+          (typeof args?.content === "string" &&
+            args.content.trim().length > 0) ||
+          args?.contentFromAttachment !== undefined ||
+          args?.contentFromWorkspaceFile !== undefined;
+        if (
+          fullReplacementRequested &&
+          !coerceBoolean(args?.allowFullReplacement)
+        ) {
+          const message =
+            "Full extension-body replacement was blocked to preserve the existing visual design. Read the current extension and use focused patches/edits for a data-only repair. Only retry with allowFullReplacement=true when the user explicitly requested a broad visual rewrite or supplied a complete replacement body.";
+          throw new AgentActionStopError(message, {
+            errorCode: "extension_full_replacement_requires_explicit_intent",
+            toolResult: JSON.stringify(
+              {
+                error: "extension_full_replacement_requires_explicit_intent",
+                message,
+                recoverable: false,
+                next: "Call get-extension once, then update-extension with patches or edits that change only the data-loading code. Use allowFullReplacement=true only for an explicitly requested visual rewrite.",
+              },
+              null,
+              2,
+            ),
+          });
+        }
+
         // Full-replacement content can come inline (`content`) or by reference
         // (`contentFromAttachment`) so the model never has to re-type a large
         // pasted file. Inline wins only when NON-EMPTY — the docstring tells
@@ -718,12 +778,33 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           if (args?.edits !== undefined && !edits) {
             return "Error: edits must be a JSON array of supported extension edit operations.";
           }
-          result = await updateExtensionContent(id, {
-            content: replacementContent,
-            patches,
-            edits,
-            format: coerceBoolean(args?.format),
-          });
+          try {
+            result = await updateExtensionContent(id, {
+              content: replacementContent,
+              allowFullReplacement: coerceBoolean(args?.allowFullReplacement),
+              patches,
+              edits,
+              format: coerceBoolean(args?.format),
+            });
+          } catch (error) {
+            if (!(error instanceof ExtensionContentEditError)) throw error;
+            const message =
+              `The extension edit was not applied: ${error.message} ` +
+              "Do not retry the same arguments. Read the current extension and submit one focused patch or edit with an exact target.";
+            throw new AgentActionStopError(message, {
+              errorCode: "extension_content_edit_failed",
+              toolResult: JSON.stringify(
+                {
+                  error: "extension_content_edit_failed",
+                  message: error.message,
+                  recoverable: false,
+                  next: "Read the current extension with get-extension, then make one focused update-extension patches/edits call. Do not retry unchanged arguments.",
+                },
+                null,
+                2,
+              ),
+            });
+          }
         }
 
         const meta: Record<string, string> = {};
@@ -1492,7 +1573,7 @@ function coerceLimit(value: unknown): number {
 
 function parsePatches(value: unknown): ExtensionLegacyPatch[] | undefined {
   if (value === undefined) return undefined;
-  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  const parsed = parseJsonArray(value);
   if (!Array.isArray(parsed)) return undefined;
   if (
     parsed.some(
@@ -1509,13 +1590,22 @@ function parsePatches(value: unknown): ExtensionLegacyPatch[] | undefined {
 
 function parseEdits(value: unknown): ExtensionContentEdit[] | undefined {
   if (value === undefined) return undefined;
-  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  const parsed = parseJsonArray(value);
   if (!Array.isArray(parsed)) return undefined;
   return parsed.every(isValidContentEdit)
     ? (parsed as ExtensionContentEdit[])
     : undefined;
 }
 
+function parseJsonArray(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return undefined;
+  }
+}
+
 function isValidContentEdit(value: unknown): boolean {
   if (!value || typeof value !== "object") return false;
   const edit = value as Record<string, unknown>;

package/corpus/core/src/extensions/content-patch.ts

@@ -64,6 +64,15 @@ export type ExtensionContentEdit =
       required?: boolean;
     };
 
+export class ExtensionContentEditError extends Error {
+  readonly code = "extension_content_edit_failed";
+
+  constructor(message: string) {
+    super(message);
+    this.name = "ExtensionContentEditError";
+  }
+}
+
 export interface ExtensionContentUpdateOpts {
   content?: string;
   patches?: ExtensionLegacyPatch[];
@@ -80,6 +89,19 @@ export interface ExtensionContentUpdateResult {
 export async function applyExtensionContentUpdate(
   currentContent: string,
   opts: ExtensionContentUpdateOpts,
+): Promise<ExtensionContentUpdateResult> {
+  try {
+    return await applyExtensionContentUpdateUnchecked(currentContent, opts);
+  } catch (error) {
+    if (error instanceof ExtensionContentEditError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ExtensionContentEditError(message);
+  }
+}
+
+async function applyExtensionContentUpdateUnchecked(
+  currentContent: string,
+  opts: ExtensionContentUpdateOpts,
 ): Promise<ExtensionContentUpdateResult> {
   let content = opts.content ?? currentContent;
   const applied: string[] = [];

package/corpus/core/src/extensions/routes.ts

@@ -24,6 +24,7 @@ import {
 } from "../server/request-context.js";
 import { ForbiddenError, resolveAccess } from "../sharing/access.js";
 import { ROLE_RANK, type ShareRole } from "../sharing/schema.js";
+import { ExtensionContentEditError } from "./content-patch.js";
 import { buildExtensionHtml, EXTENSION_IFRAME_CSP } from "./html-shell.js";
 import {
   getLocalExtension,
@@ -102,6 +103,10 @@ export function createExtensionsHandler() {
         setResponseStatus(event, 403);
         return { error: err.message };
       }
+      if (err instanceof ExtensionContentEditError) {
+        setResponseStatus(event, 400);
+        return { error: err.message, errorCode: err.code };
+      }
       throw err;
     }
   });
@@ -373,6 +378,16 @@ async function dispatch(
     const localResponse = await localExtensionSqlOnlyResponse(event, parts[0]);
     if (localResponse) return localResponse;
     const body = await readBody(event);
+    if (
+      typeof body.visibility === "string" &&
+      body.visibility.trim().toLowerCase() === "public"
+    ) {
+      setResponseStatus(event, 403);
+      return {
+        error:
+          "Extensions cannot be made public — use private or org visibility instead. No content changes were applied.",
+      };
+    }
     const hasContentUpdate =
       body.content !== undefined ||
       body.patches !== undefined ||
@@ -388,6 +403,9 @@ async function dispatch(
     if (hasContentUpdate) {
       result = await updateExtensionContent(parts[0], {
         content: body.content,
+        allowFullReplacement:
+          body.allowFullReplacement === true ||
+          body.allowFullReplacement === "true",
         patches: body.patches,
         edits: body.edits,
         format: body.format === true || body.format === "true",

package/corpus/core/src/extensions/store.ts

@@ -30,6 +30,7 @@ import {
 } from "./change-marker.js";
 import {
   applyExtensionContentUpdate,
+  ExtensionContentEditError,
   type ExtensionContentEdit,
   type ExtensionLegacyPatch,
 } from "./content-patch.js";
@@ -1166,6 +1167,7 @@ export async function updateExtension(
 
 export interface UpdateExtensionContentOpts {
   content?: string;
+  allowFullReplacement?: boolean;
   patches?: ExtensionLegacyPatch[];
   edits?: ExtensionContentEdit[];
   format?: boolean;
@@ -1188,6 +1190,12 @@ export async function updateExtensionContent(
     return null;
   }
 
+  if (opts.content !== undefined && opts.allowFullReplacement !== true) {
+    throw new ExtensionContentEditError(
+      "Full extension-body replacement requires explicit allowFullReplacement=true. Use patches or edits for a targeted data-only repair so the existing design is preserved.",
+    );
+  }
+
   const existingRows = await db
     .select()
     .from(extensions)

package/corpus/core/src/index.ts

@@ -299,6 +299,9 @@ export {
   type WorkspaceConnectionPublicCredentialRef,
   type WorkspaceConnectionStatus,
   workspaceConnectionIsAvailableToApp,
+  registerWorkspaceConnectionLifecycleListener,
+  type WorkspaceConnectionLifecycleEvent,
+  type WorkspaceConnectionLifecycleListener,
 } from "./workspace-connections/index.js";
 
 // Reusable workspace connection provider catalog

package/corpus/core/src/ingestion/docx.ts

@@ -0,0 +1,158 @@
+export interface ParsedDocxSection {
+  heading: string;
+  content: string;
+  html: string;
+  text: string;
+}
+
+export interface ParsedDocxDocument {
+  title: string;
+  html: string;
+  text: string;
+  sections: ParsedDocxSection[];
+}
+
+export async function parseDocxDocument(
+  data: Uint8Array,
+): Promise<ParsedDocxDocument> {
+  const mammoth = await loadMammoth();
+  const buffer = Buffer.from(data);
+  const [htmlResult, textResult] = await Promise.all([
+    mammoth.convertToHtml({ buffer }),
+    mammoth.extractRawText({ buffer }),
+  ]);
+  const html = sanitizeInertDocumentHtml(htmlResult.value);
+  const text = textResult.value;
+  const sections = extractDocxSections(html);
+  const firstLine = text.split("\n").find((line) => line.trim());
+  return {
+    title:
+      sections.find((section) => section.heading)?.heading ??
+      (firstLine && firstLine.length < 200
+        ? firstLine.trim()
+        : "Imported Document"),
+    html,
+    text,
+    sections,
+  };
+}
+
+export function extractDocxSections(html: string): ParsedDocxSection[] {
+  html = sanitizeInertDocumentHtml(html);
+  const sections: ParsedDocxSection[] = [];
+  for (const part of html.split(/(?=<h[1-3][^>]*>)/i)) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const heading = trimmed.match(/^<h[1-3][^>]*>(.*?)<\/h[1-3]>/is);
+    if (heading) {
+      const sectionHtml = trimmed.slice(heading[0].length).trim();
+      sections.push({
+        heading: stripHtml(heading[1]).trim(),
+        content: sectionHtml,
+        html: sectionHtml,
+        text: stripHtml(sectionHtml),
+      });
+    } else if (sections.length === 0) {
+      sections.push({
+        heading: "",
+        content: trimmed,
+        html: trimmed,
+        text: stripHtml(trimmed),
+      });
+    } else {
+      const previous = sections.at(-1)!;
+      previous.html += `\n${trimmed}`;
+      previous.content = previous.html;
+      previous.text = stripHtml(previous.html);
+    }
+  }
+  return sections.length > 0
+    ? sections
+    : html.trim()
+      ? [{ heading: "", content: html, html, text: stripHtml(html) }]
+      : [];
+}
+
+const SAFE_DOCUMENT_TAGS = new Set([
+  "p",
+  "br",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "u",
+  "s",
+  "blockquote",
+  "pre",
+  "code",
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "hr",
+  "sup",
+  "sub",
+]);
+
+export function sanitizeInertDocumentHtml(value: string): string {
+  return value
+    .replace(/<!--[^]*?-->/g, "")
+    .replace(/<!\s*(?:doctype|entity)[^>]*>/gi, "")
+    .replace(/<\?[^>]*>/g, "")
+    .replace(
+      /<\s*(script|style|iframe|object|embed|svg|math|template|noscript|form)\b[^>]*>[^]*?<\s*\/\s*\1\s*>/gi,
+      "",
+    )
+    .replace(
+      /<\s*\/?\s*([a-z][a-z0-9:-]*)\b[^>]*>/gi,
+      (tag, rawName: string) => {
+        const name = rawName.toLowerCase();
+        if (!SAFE_DOCUMENT_TAGS.has(name)) return "";
+        const closing = /^<\s*\//.test(tag);
+        if (closing && (name === "br" || name === "hr")) return "";
+        return closing ? `</${name}>` : `<${name}>`;
+      },
+    )
+    .trim();
+}
+
+function stripHtml(value: string): string {
+  return value
+    .replace(/<br\s*\/?\s*>/gi, "\n")
+    .replace(/<\/p>/gi, "\n")
+    .replace(/<[^>]+>/g, "")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .trim();
+}
+
+async function loadMammoth(): Promise<{
+  convertToHtml(input: { buffer: Buffer }): Promise<{ value: string }>;
+  extractRawText(input: { buffer: Buffer }): Promise<{ value: string }>;
+}> {
+  const moduleName = "mammoth";
+  try {
+    return (await import(moduleName)) as {
+      convertToHtml(input: { buffer: Buffer }): Promise<{ value: string }>;
+      extractRawText(input: { buffer: Buffer }): Promise<{ value: string }>;
+    };
+  } catch {
+    throw new Error(
+      "Structured DOCX parsing requires the optional mammoth dependency.",
+    );
+  }
+}