@agent-native/core 0.80.0 → 0.80.1

package/corpus/templates/analytics/server/plugins/onboarding.ts

@@ -0,0 +1,97 @@
+/**
+ * Custom onboarding plugin for Analytics.
+ *
+ * Overrides the framework's default onboarding plugin to add an optional
+ * "Session replay storage" step and register the S3 file upload provider. Must
+ * live in server/plugins/ so the framework skips its default onboarding plugin,
+ * and all registrations share the same module context as the onboarding route
+ * handlers (which read from the same in-memory Map).
+ *
+ * The step is `required: false` because session replay is opt-in: capturing
+ * replays only matters once a site embeds the tracking SDK with replay enabled,
+ * so we surface storage setup without forcing it into the onboarding checklist.
+ */
+
+import { registerFileUploadProvider } from "@agent-native/core/file-upload";
+import {
+  createOnboardingPlugin,
+  registerOnboardingStep,
+} from "@agent-native/core/onboarding";
+
+import { hasRequestReplayStorage } from "../lib/replay-storage.js";
+import { s3FileUploadProvider } from "../lib/s3-upload-provider.js";
+
+const basePlugin = createOnboardingPlugin();
+
+export default async (nitroApp: any): Promise<void> => {
+  // Mount the framework's default onboarding plugin (routes + default steps).
+  await basePlugin(nitroApp);
+
+  // Register S3-compatible file upload provider for session-replay chunks.
+  registerFileUploadProvider(s3FileUploadProvider);
+
+  // Add the optional "Session replay storage" onboarding step.
+  registerOnboardingStep({
+    id: "replay-storage",
+    order: 15,
+    required: false,
+    title: "Session replay storage",
+    description:
+      "Store session replay recordings with Builder.io or S3-compatible storage.",
+    methods: [
+      {
+        id: "builder",
+        kind: "builder-cli-auth",
+        label: "Connect Builder.io",
+        description:
+          "Builder.io's free tier includes object storage for replay chunks.",
+        primary: true,
+        badge: "free",
+        payload: { scope: "browser" },
+      },
+      {
+        id: "s3",
+        kind: "form",
+        label: "Use S3-compatible storage",
+        description:
+          "AWS S3, Cloudflare R2, DigitalOcean Spaces, MinIO, or any S3-compatible service.",
+        payload: {
+          writeScope: "workspace",
+          fields: [
+            {
+              key: "S3_ENDPOINT",
+              label: "Endpoint URL",
+              placeholder: "https://s3.us-east-1.amazonaws.com",
+            },
+            {
+              key: "S3_BUCKET",
+              label: "Bucket name",
+              placeholder: "my-replays-bucket",
+            },
+            {
+              key: "S3_ACCESS_KEY_ID",
+              label: "Access key ID",
+              placeholder: "AKIA...",
+            },
+            {
+              key: "S3_SECRET_ACCESS_KEY",
+              label: "Secret access key",
+              secret: true,
+            },
+            {
+              key: "S3_REGION",
+              label: "Region (optional)",
+              placeholder: "us-east-1",
+            },
+            {
+              key: "S3_PUBLIC_BASE_URL",
+              label: "Public base URL (optional)",
+              placeholder: "https://cdn.example.com",
+            },
+          ],
+        },
+      },
+    ],
+    isComplete: hasRequestReplayStorage,
+  });
+};

package/corpus/templates/clips/desktop/src/lib/recorder.ts

@@ -2069,6 +2069,8 @@ async function startNativeFullscreenRecording(
         .then(() => {
           pausedAt = at;
           emitState();
+          console.log("[clips-recorder] native pause: pausing transcription");
+          void transcriptionCapture?.pause().catch(() => {});
         })
         .catch((err) => {
           console.warn("[clips-recorder] native pause failed:", err);
@@ -2076,6 +2078,8 @@ async function startNativeFullscreenRecording(
     }),
     listen("clips:recorder-resume", () => {
       if (pausedAt == null) return;
+      // Only resume transcription once the recorder actually resumed, so a
+      // rejected IPC can't leave transcription running over a paused recording.
       invoke("native_fullscreen_recording_resume")
         .then(() => {
           if (pausedAt != null) {
@@ -2083,6 +2087,8 @@ async function startNativeFullscreenRecording(
             pausedAt = null;
           }
           emitState();
+          console.log("[clips-recorder] native resume: resuming transcription");
+          void transcriptionCapture?.resume().catch(() => {});
         })
         .catch((err) => {
           console.warn("[clips-recorder] native resume failed:", err);
@@ -2125,6 +2131,12 @@ async function startNativeFullscreenRecording(
     if (stopped && transcriptionCapture) {
       void transcriptionCapture.cancel().catch(() => {});
       transcriptionCapture = null;
+    } else if (pausedAt != null && transcriptionCapture) {
+      // The user paused while the engine was still starting; honor it now.
+      console.log(
+        "[clips-recorder] native: paused during startup, pausing transcription",
+      );
+      void transcriptionCapture.pause().catch(() => {});
     } else if (
       wantsAudio &&
       !transcriptionCapture &&
@@ -2885,6 +2897,8 @@ async function startRecordingInner(
           recorder.pause();
           pausedAt = Date.now();
           emitState(true);
+          console.log("[clips-recorder] recorder pause: pausing transcription");
+          void transcriptionCapture?.pause().catch(() => {});
         } catch {
           // ignore
         }
@@ -2897,6 +2911,10 @@ async function startRecordingInner(
           if (pausedAt) accumulatedPauseMs += Date.now() - pausedAt;
           pausedAt = null;
           emitState(false);
+          console.log(
+            "[clips-recorder] recorder resume: resuming transcription",
+          );
+          void transcriptionCapture?.resume().catch(() => {});
         } catch {
           // ignore
         }
@@ -2951,6 +2969,12 @@ async function startRecordingInner(
   if (stopped && transcriptionCapture) {
     void transcriptionCapture.cancel().catch(() => {});
     transcriptionCapture = null;
+  } else if (pausedAt != null && transcriptionCapture) {
+    // The user paused while the engine was still starting; honor it now.
+    console.log(
+      "[clips-recorder] recorder: paused during startup, pausing transcription",
+    );
+    void transcriptionCapture.pause().catch(() => {});
   } else if (
     wantsAudio &&
     !transcriptionCapture &&

package/corpus/templates/clips/desktop/src/lib/transcription-capture.ts

@@ -41,6 +41,10 @@ export interface CapturedTranscript {
 export interface TranscriptionCapture {
   stop(): Promise<CapturedTranscript>;
   cancel(): Promise<void>;
+  /** Suspend the audio engine without discarding the captured transcript. */
+  pause(): Promise<void>;
+  /** Restart the audio engine after a `pause()`. */
+  resume(): Promise<void>;
 }
 
 interface SpeechRecognitionResultLike {
@@ -154,6 +158,7 @@ async function startBrowserTranscriptionCapture(): Promise<TranscriptionCapture
   const recognition = new Ctor();
   let disposed = false;
   let stopped = false;
+  let paused = false;
   const transcriptBuffer = createWebSpeechTranscriptBuffer();
   let stopResolver: ((value: CapturedTranscript) => void) | null = null;
   let settleTimer: ReturnType<typeof window.setTimeout> | null = null;
@@ -195,11 +200,13 @@ async function startBrowserTranscriptionCapture(): Promise<TranscriptionCapture
 
   recognition.onend = () => {
     if (disposed) return;
-    transcriptBuffer.commitSession({ preserveInterim: stopped });
+    transcriptBuffer.commitSession({ preserveInterim: stopped || paused });
     if (stopped) {
       settleStop();
       return;
     }
+    // While paused, keep the committed transcript but don't restart the engine.
+    if (paused) return;
     try {
       recognition.start();
     } catch (err) {
@@ -245,6 +252,29 @@ async function startBrowserTranscriptionCapture(): Promise<TranscriptionCapture
         // ignore
       }
     },
+    async pause() {
+      if (disposed || stopped || paused) return;
+      paused = true;
+      console.log("[clips-recorder] transcription paused (web-speech)");
+      try {
+        recognition.stop();
+      } catch {
+        // ignore
+      }
+    },
+    async resume() {
+      if (disposed || stopped || !paused) return;
+      paused = false;
+      console.log("[clips-recorder] transcription resumed (web-speech)");
+      try {
+        recognition.start();
+      } catch (err) {
+        console.warn(
+          "[clips-recorder] Web Speech transcription resume failed:",
+          err,
+        );
+      }
+    },
   };
 }
 
@@ -260,6 +290,13 @@ export async function startTranscriptionCapture(
   const lines: string[] = [];
   const segments: SourcedTranscriptSegment[] = [];
   let disposed = false;
+  let paused = false;
+  let desiredPaused = false;
+  let transitioning = false;
+  // When a pause stops the engine, Whisper still flushes trailing finals
+  // asynchronously. Track when those are expected to have landed so a stop
+  // soon after a pause waits for them instead of dropping the last words.
+  let pauseFinalsSettleUntil = 0;
   const unlistens: UnlistenFn[] = [];
 
   const cleanup = () => {
@@ -299,8 +336,59 @@ export async function startTranscriptionCapture(
       : null;
   }
 
+  // Pause/resume run fire-and-forget from the recorder, so a quick
+  // pause→resume can arrive while a transition is still awaiting the engine.
+  // Track the desired state and re-apply once the in-flight transition settles
+  // so the last request always wins (instead of being dropped).
+  const applyAudioState = async () => {
+    if (transitioning || disposed || desiredPaused === paused) return;
+    transitioning = true;
+    try {
+      if (desiredPaused) {
+        await stopTranscriptionEngine(engine);
+        paused = true;
+        pauseFinalsSettleUntil = Date.now() + WHISPER_STOP_SETTLE_MS;
+        console.log(`[clips-recorder] transcription paused (${engine})`);
+      } else {
+        engine = await startTranscriptionEngine({ mic, captureSystem });
+        // stop()/cancel() can run during the await above; if it did, the new
+        // engine would leak (mic/system capture stays live). Tear it down.
+        if (disposed) {
+          await stopTranscriptionEngine(engine).catch(() => {});
+          return;
+        }
+        paused = false;
+        console.log(`[clips-recorder] transcription resumed (${engine})`);
+      }
+    } catch (err) {
+      // Transition failed. Keep `desiredPaused` as the still-unmet intent (don't
+      // reset it) so the next pause/resume toggle retries and converges, and
+      // return early so we don't busy-loop re-applying a persistently failing
+      // transition. `paused` still reflects the real engine state.
+      console.warn(
+        `[clips-recorder] transcription ${desiredPaused ? "pause" : "resume"} failed; engine still ${paused ? "paused" : "live"}:`,
+        err,
+      );
+      // `finally` resets `transitioning`; returning skips the auto re-apply.
+      return;
+    } finally {
+      transitioning = false;
+    }
+    // Re-apply in case the desired state changed mid-transition.
+    void applyAudioState();
+  };
+
   return {
     async stop() {
+      // Already paused: the engine is stopped, but the pause-time flush may
+      // still be in flight. Wait out any remaining settle window so trailing
+      // finals land before we drop the listener.
+      if (paused) {
+        const remaining = pauseFinalsSettleUntil - Date.now();
+        if (remaining > 0) await wait(remaining);
+        cleanup();
+        return captured();
+      }
       try {
         await stopTranscriptionEngine(engine);
       } catch (err) {
@@ -314,12 +402,24 @@ export async function startTranscriptionCapture(
       return captured();
     },
     async cancel() {
-      try {
-        await stopTranscriptionEngine(engine);
-      } catch {
-        // ignore
+      if (!paused) {
+        try {
+          await stopTranscriptionEngine(engine);
+        } catch {
+          // ignore
+        }
       }
       cleanup();
     },
+    async pause() {
+      if (disposed) return;
+      desiredPaused = true;
+      await applyAudioState();
+    },
+    async resume() {
+      if (disposed) return;
+      desiredPaused = false;
+      await applyAudioState();
+    },
   };
 }

package/corpus/templates/content/actions/set-image-alt-text.ts

@@ -52,7 +52,7 @@ function imageAltCandidates({
   const candidates: ImageAltCandidate[] = [];
 
   const markdownImagePattern = new RegExp(
-    `!\\[[^\\]]*\\]\\((${escapedUrl})(\\s+\"[^\"]*\")?\\)`,
+    `!\\[[^\\]]*\\]\\((${escapedUrl})(\\s+"[^"]*")?\\)`,
     "g",
   );
   for (const match of content.matchAll(markdownImagePattern)) {

package/corpus/templates/content/shared/document-export.ts

@@ -115,7 +115,7 @@ function inlineMarkdownToHtml(text: string): string {
     .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
     .replace(/__([^_]+)__/g, "<strong>$1</strong>")
     .replace(/~~([^~]+)~~/g, "<s>$1</s>")
-    .replace(/(^|[^\*])\*([^*]+)\*/g, "$1<em>$2</em>")
+    .replace(/(^|[^*])\*([^*]+)\*/g, "$1<em>$2</em>")
     .replace(/(^|[^_])_([^_]+)_/g, "$1<em>$2</em>");
 }
 

package/corpus/templates/design/.agents/skills/design-systems/SKILL.md

@@ -145,18 +145,18 @@ Returns CSS custom properties, colors, fonts, Google Fonts links, theme-color, O
 ### Source: GitHub Repository
 
 ```bash
-pnpm action import-github --repoUrl "https://github.com/acme/ui"
+pnpm action index-design-system-with-builder --githubRepoUrl "https://github.com/acme/ui"
 ```
 
-Fetches Tailwind configs, CSS files, theme files, package.json. Returns extracted colors, fonts, spacing, border-radius, and styling framework detection.
+Starts Builder design-system indexing for the repository. Builder is the source of truth for the indexed brand kit, generated docs, and usage guidance. If Builder is not connected, stop and ask the user to connect Builder.
 
 ### Source: Local Code Files
 
 ```bash
-pnpm action import-code --files '[{"filename":"globals.css","content":"..."}]'
+pnpm action index-design-system-with-builder --codeFiles '[{"filename":"globals.css","content":"..."}]'
 ```
 
-Analyzes CSS, Tailwind configs, JSON theme files, TS/JS theme files. Returns structured tokens.
+Uploads code/design files to Builder and starts design-system indexing. Do not create a local design system from uploaded code files unless the user explicitly asks for a manual local fallback.
 
 ### Source: Documents (DOCX, PPTX, PDF)
 
@@ -192,20 +192,10 @@ effects to CSS box-shadow, and text styles to font tokens; snap spacing to a
 4/8px scale. If no Figma MCP is connected, ask the user to paste the token
 values or describe the file.
 
-**When the user uploads a raw `.fig` file**, parse it in-process with
-`import-figma-file` (no Figma account needed):
-
-```bash
-pnpm action import-figma-file --fileBase64 "<base64 of the .fig>"   # or --fileDataUrl
-```
-
-It decodes the binary `.fig`, returns `frames` (each Figma frame rendered to
-HTML), an extracted `designSystem` (colors with assigned roles, typography,
-spacing, radius, shadows — ready for `DesignSystemData`), and image metadata.
-It's read-only/preview: review the result, then call `create-design-system`
-with the `designSystem` and/or `create-design` + `generate-design` with the
-`frames`. The full `palette` is returned too, so re-assign a color role if a
-heuristic looks off.
+**When the user uploads a raw `.fig` file**, send it to Builder design-system
+indexing through the setup page upload route. Do not parse `.fig` files locally
+and do not call `create-design-system` from raw `.fig` output; Builder owns the
+indexed brand kit, generated docs, and usage guidance.
 
 ### Source: Brand Analysis (combines website + notes)
 

package/corpus/templates/design/.agents/skills/visual-edit/SKILL.md

@@ -28,6 +28,9 @@ iframe-backed screens on the infinite canvas.
   new flow state.
 - Flow visualization is just multiple URL states: `/checkout?step=shipping`,
   `/checkout?step=payment`, `/checkout?step=done`, etc.
+- When the user gives a named flow or numbered screen list, preserve that order
+  and create one screen per URL/path. Shorthand like
+  `localhost:1234/onboarding/1` means `http://localhost:1234/onboarding/1`.
 
 ## Required Local Bridge
 
@@ -92,6 +95,20 @@ pnpm action add-localhost-screens '{
 }'
 ```
 
+For a numbered flow the user describes in chat, keep the labels and order:
+
+```bash
+pnpm action add-localhost-screens '{
+  "designId": "<design-id>",
+  "connectionId": "<connection-id>",
+  "routes": [
+    { "url": "localhost:1234/onboarding/1", "title": "Screen 1" },
+    { "url": "localhost:1234/onboarding/2", "title": "Screen 2" },
+    { "url": "localhost:1234/onboarding/3", "title": "Screen 3" }
+  ]
+}'
+```
+
 If no `routes` or `paths` are supplied, `add-localhost-screens` uses every route
 from the latest localhost manifest. Use `paths` for a concise flow:
 

package/corpus/templates/design/actions/add-localhost-screens.ts

@@ -67,14 +67,40 @@ function normalizeBaseUrl(value: string): string {
   return parsed.toString().replace(/\/$/, "");
 }
 
-function routeUrl(baseUrl: string, route: { path?: string; url?: string }) {
+function withLocalhostProtocol(value: string): string {
+  const raw = value.trim();
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) return raw;
+  if (
+    /^(localhost|127(?:\.\d{1,3}){3}|0\.0\.0\.0|\[::1\]|::1)(?::\d+)?(?:[/?#]|$)/i.test(
+      raw,
+    )
+  ) {
+    return `http://${raw}`;
+  }
+  return raw;
+}
+
+export function routeUrl(
+  baseUrl: string,
+  route: { path?: string; url?: string },
+) {
   const raw = route.url ?? route.path ?? "/";
-  const parsed = new URL(raw, `${baseUrl}/`);
+  let parsed: URL;
+  try {
+    parsed = new URL(withLocalhostProtocol(raw), `${baseUrl}/`);
+  } catch {
+    throw new Error(
+      `Invalid localhost screen URL "${raw}". Use a path like /pricing or an http(s) localhost URL.`,
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Localhost screen URL must be an http(s) URL: ${raw}`);
+  }
   parsed.hash = "";
   return parsed.toString();
 }
 
-function pathFromUrl(baseUrl: string, url: string, fallback?: string) {
+export function pathFromUrl(baseUrl: string, url: string, fallback?: string) {
   try {
     const parsed = new URL(url);
     const base = new URL(baseUrl);
@@ -87,10 +113,11 @@ function pathFromUrl(baseUrl: string, url: string, fallback?: string) {
   return fallback ?? "/";
 }
 
-function slugForPath(pathOrUrl: string) {
+export function slugForPath(pathOrUrl: string) {
   const parsed = (() => {
     try {
-      return new URL(pathOrUrl).pathname + new URL(pathOrUrl).search;
+      const url = new URL(withLocalhostProtocol(pathOrUrl));
+      return url.pathname + url.search;
     } catch {
       return pathOrUrl;
     }