@agent-native/core 0.101.3 → 0.101.4

package/corpus/templates/clips/chrome-extension/src/offscreen.ts

@@ -36,6 +36,13 @@ import {
 import { MAX_UPLOAD_BYTES } from "@shared/upload-limits";
 
 import { waitForReadyRecordingAfterFinalizeError } from "./finalize-recovery";
+import {
+  createRecordingDurationState,
+  pauseRecordingDuration,
+  resumeRecordingDuration,
+  startRecordingDuration,
+  type RecordingDurationState,
+} from "./recording-duration";
 import { captureExtensionError, initExtensionSentry } from "./sentry";
 
 initExtensionSentry("offscreen");
@@ -187,6 +194,7 @@ type ActiveRecording = {
   authToken: string | null;
   mode: CaptureMode;
   startedAtMs: number;
+  duration: RecordingDurationState;
   mimeType: string;
   recorder: MediaRecorder;
   outputStream: MediaStream;
@@ -1218,6 +1226,7 @@ async function begin(message: BeginMessage): Promise<{
     authToken: message.authToken ?? null,
     mode: ready.mode,
     startedAtMs: 0,
+    duration: createRecordingDurationState(),
     mimeType,
     recorder,
     outputStream,
@@ -1350,6 +1359,7 @@ function startRecorderNow(recording: ActiveRecording): void {
     playStartChime();
     recording.recorder.start(2000);
     recording.startedAtMs = Date.now();
+    recording.duration = startRecordingDuration(recording.startedAtMs);
     console.log("[clips-offscreen] recorder.start ok");
     reportStatus(recording.sessionId, "recording", {
       recordingId: recording.recordingId,
@@ -1446,6 +1456,11 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
     recording.resolveStopped({ ok: true, status: "cancelled" });
     return;
   }
+  // Freeze the media duration as soon as MediaRecorder stops. Waiting for
+  // outstanding uploads below must not make the clip appear longer, and time
+  // spent paused is excluded by pauseRecordingDuration().
+  recording.duration = pauseRecordingDuration(recording.duration, Date.now());
+  const durationMs = recording.duration.elapsedMs;
   reportStatus(recording.sessionId, "uploading", {
     recordingId: recording.recordingId,
   });
@@ -1460,7 +1475,6 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
         ? rejected.reason
         : new Error(String(rejected.reason));
     }
-    const durationMs = Math.max(0, Date.now() - recording.startedAtMs);
     // Surface WHY a finalize might fail before the server's cryptic "No chunks
     // found": 0 chunks means the recorder emitted no non-empty data (empty
     // capture / never started), which is a different problem than an auth 401.
@@ -1549,7 +1563,7 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
         recordingId: recording.recordingId,
         chunkCount: recording.chunkIndex,
         mimeType: recording.mimeType,
-        durationMs: Math.max(0, Date.now() - recording.startedAtMs),
+        durationMs,
       },
     });
     // The upload failed — save the buffered recording to disk so it isn't lost.
@@ -1574,7 +1588,13 @@ async function finalizeStop(recording: ActiveRecording): Promise<void> {
 function pause(message: SimpleMessage): { ok: boolean } {
   const recording = activeRecording;
   if (recording && recording.sessionId === message.sessionId) {
-    if (recording.recorder.state === "recording") recording.recorder.pause();
+    if (recording.recorder.state === "recording") {
+      recording.recorder.pause();
+      recording.duration = pauseRecordingDuration(
+        recording.duration,
+        Date.now(),
+      );
+    }
     reportStatus(recording.sessionId, "paused", {
       recordingId: recording.recordingId,
     });
@@ -1585,7 +1605,13 @@ function pause(message: SimpleMessage): { ok: boolean } {
 function resume(message: SimpleMessage): { ok: boolean } {
   const recording = activeRecording;
   if (recording && recording.sessionId === message.sessionId) {
-    if (recording.recorder.state === "paused") recording.recorder.resume();
+    if (recording.recorder.state === "paused") {
+      recording.recorder.resume();
+      recording.duration = resumeRecordingDuration(
+        recording.duration,
+        Date.now(),
+      );
+    }
     reportStatus(recording.sessionId, "recording", {
       recordingId: recording.recordingId,
     });

package/corpus/templates/clips/chrome-extension/src/recording-duration.ts

@@ -0,0 +1,32 @@
+export type RecordingDurationState = {
+  elapsedMs: number;
+  activeSinceMs: number | null;
+};
+
+export function createRecordingDurationState(): RecordingDurationState {
+  return { elapsedMs: 0, activeSinceMs: null };
+}
+
+export function startRecordingDuration(nowMs: number): RecordingDurationState {
+  return { elapsedMs: 0, activeSinceMs: nowMs };
+}
+
+export function pauseRecordingDuration(
+  state: RecordingDurationState,
+  nowMs: number,
+): RecordingDurationState {
+  if (state.activeSinceMs === null) return state;
+  return {
+    elapsedMs:
+      state.elapsedMs + Math.max(0, Math.round(nowMs - state.activeSinceMs)),
+    activeSinceMs: null,
+  };
+}
+
+export function resumeRecordingDuration(
+  state: RecordingDurationState,
+  nowMs: number,
+): RecordingDurationState {
+  if (state.activeSinceMs !== null) return state;
+  return { ...state, activeSinceMs: nowMs };
+}

package/corpus/templates/slides/actions/_uploaded-files.ts

@@ -4,11 +4,19 @@ import path from "path";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 
 import { tenantUploadDir } from "../server/lib/tenant-files.js";
+import { readUploadedReferenceBlob } from "../server/lib/uploaded-reference-storage.js";
 
-export function resolveUserUploadedFile(filePath: string): string {
+export async function readUserUploadedFile(
+  filePath: string,
+): Promise<{ data: Buffer; filename: string }> {
   const email = getRequestUserEmail();
   if (!email) throw new Error("no authenticated user");
 
+  const privateUpload = await readUploadedReferenceBlob(filePath, email);
+  if (privateUpload) {
+    return privateUpload;
+  }
+
   const allowedDir = tenantUploadDir(email);
   const absPath = path.isAbsolute(filePath)
     ? filePath
@@ -23,5 +31,8 @@ export function resolveUserUploadedFile(filePath: string): string {
   if (!fs.existsSync(resolved)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  return resolved;
+  return {
+    data: await fs.promises.readFile(resolved),
+    filename: path.basename(resolved),
+  };
 }

package/corpus/templates/slides/actions/import-docx.ts

@@ -1,11 +1,9 @@
-import fs from "fs";
-
 import { defineAction } from "@agent-native/core";
 import { z } from "zod";
 
 import { parseDocx } from "../server/handlers/import/docx-parser.js";
 import { convertSectionsToSlides } from "../server/handlers/import/html-converter.js";
-import { resolveUserUploadedFile } from "./_uploaded-files.js";
+import { readUserUploadedFile } from "./_uploaded-files.js";
 
 export default defineAction({
   description:
@@ -16,9 +14,7 @@ export default defineAction({
   schema: z.object({
     filePath: z
       .string()
-      .describe(
-        "Server path to the uploaded DOCX file (e.g. data/uploads/document.docx)",
-      ),
+      .describe("Uploaded DOCX path or opaque hosted upload reference"),
     convertToSlides: z
       .boolean()
       .optional()
@@ -28,9 +24,7 @@ export default defineAction({
       ),
   }),
   run: async ({ filePath, convertToSlides }) => {
-    const absPath = resolveUserUploadedFile(filePath);
-
-    const fileBuffer = await fs.promises.readFile(absPath);
+    const { data: fileBuffer } = await readUserUploadedFile(filePath);
     const doc = await parseDocx(fileBuffer);
 
     const result: Record<string, unknown> = {

package/corpus/templates/slides/actions/import-file.ts

@@ -1,4 +1,3 @@
-import fs from "fs";
 import path from "path";
 
 import { defineAction } from "@agent-native/core";
@@ -15,7 +14,7 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { notifyClients } from "../server/handlers/decks.js";
 import { upsertBuilderProxyDesignSystem } from "../server/lib/builder-design-system-proxy.js";
-import { resolveUserUploadedFile } from "./_uploaded-files.js";
+import { readUserUploadedFile } from "./_uploaded-files.js";
 
 const DEFAULT_MAX_SOURCE_CHARS = 60_000;
 
@@ -30,9 +29,7 @@ export default defineAction({
   schema: z.object({
     filePath: z
       .string()
-      .describe(
-        "Server path to the uploaded file (e.g. data/uploads/file.pptx)",
-      ),
+      .describe("Uploaded file path or opaque hosted upload reference"),
     format: z
       .enum(["pptx", "docx", "pdf", "fig", "auto"])
       .optional()
@@ -60,15 +57,15 @@ export default defineAction({
       ),
   }),
   run: async ({ filePath, format, deckId, importIntoDeck, maxChars }) => {
-    const absPath = resolveUserUploadedFile(filePath);
+    const uploaded = await readUserUploadedFile(filePath);
     const sourceLimit = maxChars ?? DEFAULT_MAX_SOURCE_CHARS;
-
-    const fileBuffer = await fs.promises.readFile(absPath);
+    const fileBuffer = uploaded.data;
+    const filename = uploaded.filename;
 
     // Detect format from extension if auto
     let detectedFormat = format;
     if (detectedFormat === "auto") {
-      const ext = path.extname(absPath).toLowerCase();
+      const ext = path.extname(filename).toLowerCase();
       if (ext === ".pptx") detectedFormat = "pptx";
       else if (ext === ".docx") detectedFormat = "docx";
       else if (ext === ".pdf") detectedFormat = "pdf";
@@ -86,12 +83,12 @@ export default defineAction({
           "Figma .fig imports start Builder design-system indexing, not slide replacements. Re-run without importIntoDeck.",
         );
       }
-      const title = titleFromPath(absPath);
+      const title = titleFromPath(filename);
       const result = await startBuilderDesignSystemIndex({
         projectName: title,
         files: [
           {
-            name: path.basename(absPath),
+            name: path.basename(filename),
             data: fileBuffer,
             mimeType: "application/octet-stream",
           },
@@ -126,7 +123,7 @@ export default defineAction({
       const { convertToSlideHtml } =
         await import("../server/handlers/import/html-converter.js");
       const presentation = await parsePptx(fileBuffer);
-      const title = presentation.title || titleFromPath(absPath);
+      const title = presentation.title || titleFromPath(filename);
 
       if (importIntoDeck) {
         if (!deckId) throw new Error("deckId is required to import into deck");
@@ -172,7 +169,7 @@ export default defineAction({
         await import("../server/handlers/import/html-converter.js");
       const doc = await parseDocx(fileBuffer);
       const slideHtmlArray = convertSectionsToSlides(doc.sections);
-      const title = doc.title || titleFromPath(absPath);
+      const title = doc.title || titleFromPath(filename);
 
       if (importIntoDeck) {
         if (!deckId) throw new Error("deckId is required to import into deck");
@@ -221,7 +218,7 @@ export default defineAction({
       const result = await pdf.getText();
       const pages = normalizePdfPages(result);
       const textPages = pages.filter((p) => p.text.trim());
-      const title = titleFromPath(absPath);
+      const title = titleFromPath(filename);
 
       if (textPages.length === 0) {
         throw new Error(

package/corpus/templates/slides/actions/import-pptx.ts

@@ -1,5 +1,3 @@
-import fs from "fs";
-
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import {
@@ -15,7 +13,7 @@ import { notifyClients } from "../server/handlers/decks.js";
 import { convertToSlideHtml } from "../server/handlers/import/html-converter.js";
 import { parsePptx } from "../server/handlers/import/pptx-parser.js";
 import { getDeckUrl } from "./_app-url.js";
-import { resolveUserUploadedFile } from "./_uploaded-files.js";
+import { readUserUploadedFile } from "./_uploaded-files.js";
 
 export default defineAction({
   description:
@@ -26,9 +24,7 @@ export default defineAction({
   schema: z.object({
     filePath: z
       .string()
-      .describe(
-        "Server path to the uploaded PPTX file (e.g. data/uploads/presentation.pptx)",
-      ),
+      .describe("Uploaded PPTX path or opaque hosted upload reference"),
     deckId: z
       .string()
       .optional()
@@ -43,9 +39,7 @@ export default defineAction({
       ),
   }),
   run: async ({ filePath, deckId, title }) => {
-    const absPath = resolveUserUploadedFile(filePath);
-
-    const fileBuffer = await fs.promises.readFile(absPath);
+    const { data: fileBuffer } = await readUserUploadedFile(filePath);
     const presentation = await parsePptx(fileBuffer);
 
     const deckTitle = title || presentation.title || "Imported Presentation";

package/corpus/templates/slides/changelog/2026-07-14-powerpoint-template-uploads-now-work-in-hosted-slides-deploy.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-14
+---
+
+PowerPoint template uploads now work in hosted Slides deployments.

package/corpus/templates/slides/server/handlers/uploads.ts

@@ -1,7 +1,6 @@
 import fs from "fs";
 import path from "path";
 
-import { getSession } from "@agent-native/core/server";
 import {
   defineEventHandler,
   setResponseStatus,
@@ -14,7 +13,15 @@ import {
   isSlidesReferenceFileExtension,
 } from "../../shared/upload-types";
 import { tenantUploadDir } from "../lib/tenant-files.js";
+import {
+  isHostedSlidesRuntime,
+  storeUploadedReferenceBlob,
+} from "../lib/uploaded-reference-storage.js";
 import { canSaveAsUploadedAsset, uploadImageAsset } from "./assets.js";
+import {
+  resolveSlidesRequestAuthContext,
+  withSlidesRequestContext,
+} from "./request-auth-context.js";
 
 export const MAX_REFERENCE_FILE_BYTES = 50 * 1024 * 1024;
 export const MAX_FIG_REFERENCE_FILE_BYTES = 200 * 1024 * 1024;
@@ -113,6 +120,7 @@ function pathForAgent(absPath: string): string {
 
 export async function saveUploadedReferenceFile(args: {
   email: string;
+  orgId?: string | null;
   originalName: string;
   data: Uint8Array;
   type?: string;
@@ -127,14 +135,43 @@ export async function saveUploadedReferenceFile(args: {
   if (!hasExpectedSignature(ext, args.data)) {
     throw new Error(`File contents do not match ${ext} upload type`);
   }
-  const uploadDir = tenantUploadDir(args.email);
-  await fs.promises.mkdir(uploadDir, { recursive: true });
-  const destPath = path.join(uploadDir, filename);
-  await fs.promises.writeFile(destPath, args.data);
-  // For images, also push to the file-upload provider so the agent can embed
-  // a hosted URL (in slide HTML, chat replies, etc.). For non-image reference
-  // files (PPTX, DOCX, PDF), the on-disk path is what the agent uses via
-  // shell — no provider URL is required.
+  let uploadedPath: string;
+  if (isHostedSlidesRuntime()) {
+    let reference: string | null;
+    try {
+      reference = await storeUploadedReferenceBlob({
+        email: args.email,
+        orgId: args.orgId,
+        data: args.data,
+        filename,
+        mimeType: args.type || "application/octet-stream",
+      });
+    } catch {
+      throw Object.assign(
+        new Error("Private file storage failed while saving the upload."),
+        { statusCode: 503 },
+      );
+    }
+    if (!reference) {
+      throw Object.assign(
+        new Error(
+          "Private file storage is not configured. Connect Builder.io or another file provider before uploading reference files in a hosted Slides deployment.",
+        ),
+        { statusCode: 503 },
+      );
+    }
+    uploadedPath = reference;
+  } else {
+    const uploadDir = tenantUploadDir(args.email);
+    await fs.promises.mkdir(uploadDir, { recursive: true });
+    const destPath = path.join(uploadDir, filename);
+    await fs.promises.writeFile(destPath, args.data);
+    uploadedPath = pathForAgent(destPath);
+  }
+  // For images, also push to the public file-upload provider so the agent can
+  // embed a hosted URL (in slide HTML, chat replies, etc.). The `path` above
+  // remains the private import source: a tenant path locally and an encrypted,
+  // owner-scoped blob reference in hosted deployments.
   let url: string | undefined;
   if (
     canSaveAsUploadedAsset({
@@ -159,7 +196,7 @@ export async function saveUploadedReferenceFile(args: {
     }
   }
   return {
-    path: pathForAgent(destPath),
+    path: uploadedPath,
     url,
     originalName: args.originalName,
     filename,
@@ -170,54 +207,67 @@ export async function saveUploadedReferenceFile(args: {
 
 // Upload one or more files
 export const uploadFiles = defineEventHandler(async (event) => {
-  const session = await getSession(event).catch(() => null);
-  if (!session?.email) {
+  const authContext = await resolveSlidesRequestAuthContext(event);
+  const email = authContext.email;
+  if (!email) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };
   }
 
-  const parts = await readMultipartFormData(event);
-  const fileParts =
-    parts?.filter((p) => (p.name === "files" || p.name === "file") && p.data) ??
-    [];
+  return withSlidesRequestContext(
+    event,
+    async ({ orgId }) => {
+      const parts = await readMultipartFormData(event);
+      const fileParts =
+        parts?.filter(
+          (p) => (p.name === "files" || p.name === "file") && p.data,
+        ) ?? [];
 
-  if (fileParts.length === 0) {
-    setResponseStatus(event, 400);
-    return { error: "No files uploaded" };
-  }
+      if (fileParts.length === 0) {
+        setResponseStatus(event, 400);
+        return { error: "No files uploaded" };
+      }
 
-  const MAX_FILES = 20;
+      const MAX_FILES = 20;
 
-  if (fileParts.length > MAX_FILES) {
-    setResponseStatus(event, 413);
-    return { error: `Too many files (max ${MAX_FILES})` };
-  }
+      if (fileParts.length > MAX_FILES) {
+        setResponseStatus(event, 413);
+        return { error: `Too many files (max ${MAX_FILES})` };
+      }
 
-  const oversized = fileParts.find(
-    (p) => p.data.length > maxReferenceFileBytes(p.filename),
-  );
-  if (oversized) {
-    const limit = maxReferenceFileBytes(oversized.filename);
-    setResponseStatus(event, 413);
-    return { error: `File too large (max ${formatMaxFileSize(limit)})` };
-  }
+      const oversized = fileParts.find(
+        (p) => p.data.length > maxReferenceFileBytes(p.filename),
+      );
+      if (oversized) {
+        const limit = maxReferenceFileBytes(oversized.filename);
+        setResponseStatus(event, 413);
+        return { error: `File too large (max ${formatMaxFileSize(limit)})` };
+      }
 
-  let results;
-  try {
-    results = await Promise.all(
-      fileParts.map(async (part) => {
-        return saveUploadedReferenceFile({
-          email: session.email,
-          originalName: part.filename || "upload",
-          data: part.data,
-          type: part.type,
-        });
-      }),
-    );
-  } catch (err) {
-    setResponseStatus(event, 400);
-    return { error: err instanceof Error ? err.message : "Invalid upload" };
-  }
+      let results;
+      try {
+        results = await Promise.all(
+          fileParts.map(async (part) => {
+            return saveUploadedReferenceFile({
+              email,
+              orgId,
+              originalName: part.filename || "upload",
+              data: part.data,
+              type: part.type,
+            });
+          }),
+        );
+      } catch (err) {
+        const statusCode =
+          typeof (err as { statusCode?: unknown })?.statusCode === "number"
+            ? (err as { statusCode: number }).statusCode
+            : 400;
+        setResponseStatus(event, statusCode);
+        return { error: err instanceof Error ? err.message : "Invalid upload" };
+      }
 
-  return results;
+      return results;
+    },
+    authContext,
+  );
 });

package/corpus/templates/slides/server/lib/tenant-files.ts

@@ -10,26 +10,53 @@ export function tenantFileKey(email: string): string {
     .slice(0, 24);
 }
 
-export function tenantUploadDir(email: string): string {
-  return path.join(process.cwd(), "data", "uploads", tenantFileKey(email));
+export function tenantUploadDir(email: string, cwd = process.cwd()): string {
+  return path.join(cwd, "data", "uploads", tenantFileKey(email));
 }
 
-function exportRootDir(): string {
+export function isHostedSlidesRuntime(
+  cwd = process.cwd(),
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if (env.NETLIFY && env.NETLIFY !== "false" && env.NETLIFY_LOCAL !== "true") {
+    return true;
+  }
   if (
-    process.env.NETLIFY ||
-    process.env.VERCEL ||
-    process.env.AWS_LAMBDA_FUNCTION_NAME ||
-    process.cwd() === "/var/task" ||
-    process.cwd().startsWith("/var/task/")
+    (env.AWS_LAMBDA_FUNCTION_NAME ||
+      env.LAMBDA_TASK_ROOT ||
+      cwd === "/var/task" ||
+      cwd.startsWith("/var/task/")) &&
+    env.NETLIFY_LOCAL !== "true"
   ) {
+    return true;
+  }
+  return Boolean(
+    env.VERCEL ||
+    env.VERCEL_ENV ||
+    env.CF_PAGES ||
+    env.RENDER ||
+    env.FLY_APP_NAME ||
+    env.K_SERVICE,
+  );
+}
+
+function exportRootDir(
+  cwd = process.cwd(),
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  if (isHostedSlidesRuntime(cwd, env)) {
     return path.join(os.tmpdir(), "agent-native-slides", "exports");
   }
 
-  return path.join(process.cwd(), "data", "exports");
+  return path.join(cwd, "data", "exports");
 }
 
-export function tenantExportDir(email: string): string {
-  return path.join(exportRootDir(), tenantFileKey(email));
+export function tenantExportDir(
+  email: string,
+  cwd = process.cwd(),
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  return path.join(exportRootDir(cwd, env), tenantFileKey(email));
 }
 
 export function safeGeneratedFilename(title: string, ext: ".html" | ".pptx") {