@agenticmail/enterprise 0.5.391 → 0.5.393

package/dist/{agent-tools-2XUSIG4S.js → agent-tools-W47VHMR5.js}

@@ -103,10 +103,10 @@ function createPathSandbox(workspaceDir, opts) {
         "PATH_TRAVERSAL"
       );
     }
-    var basename2 = path.basename(normalized);
-    if (BLOCKED_BASENAMES.indexOf(basename2) !== -1) {
+    var basename3 = path.basename(normalized);
+    if (BLOCKED_BASENAMES.indexOf(basename3) !== -1) {
       throw new SecurityError(
-        "Access to sensitive file blocked: " + basename2,
+        "Access to sensitive file blocked: " + basename3,
         "PATH_BLOCKED"
       );
     }
@@ -117,7 +117,7 @@ function createPathSandbox(workspaceDir, opts) {
         "PATH_BLOCKED"
       );
     }
-    if (basename2 === "config.json" && normalized.indexOf(".docker" + path.sep) !== -1) {
+    if (basename3 === "config.json" && normalized.indexOf(".docker" + path.sep) !== -1) {
       throw new SecurityError(
         "Access to .docker/config.json blocked",
         "PATH_BLOCKED"
@@ -347,11 +347,11 @@ function computeOutputSize(result) {
   }
   return size;
 }
-function resolveRateLimiterOpts(tool, overrides) {
-  if (overrides && overrides[tool.name]) {
-    return overrides[tool.name];
+function resolveRateLimiterOpts(tool2, overrides) {
+  if (overrides && overrides[tool2.name]) {
+    return overrides[tool2.name];
   }
-  var category = tool.category || "utility";
+  var category = tool2.category || "utility";
   return DEFAULT_RATE_LIMITS[category] || { maxTokens: 60, refillRate: 60 / 60 };
 }
 var rateLimiters = /* @__PURE__ */ new Map();
@@ -364,7 +364,7 @@ function getRateLimiter(opts) {
   }
   return limiter;
 }
-function wrapToolWithMiddleware(tool, config) {
+function wrapToolWithMiddleware(tool2, config) {
   var agentId = config.agentId || "unknown";
   var auditSink = config.audit?.sink || ConsoleAuditSink;
   var auditEnabled = config.audit?.enabled !== false;
@@ -372,16 +372,16 @@ function wrapToolWithMiddleware(tool, config) {
   var cbEnabled = config.circuitBreaker?.enabled !== false;
   var telemetryEnabled = config.telemetry?.enabled !== false && !!config.telemetry?.sink;
   var telemetrySink = config.telemetry?.sink;
-  var useCircuitBreaker = cbEnabled && (tool.category === "web" || tool.category === "browser");
-  var rlOpts = resolveRateLimiterOpts(tool, config.rateLimit?.overrides);
+  var useCircuitBreaker = cbEnabled && (tool2.category === "web" || tool2.category === "browser");
+  var rlOpts = resolveRateLimiterOpts(tool2, config.rateLimit?.overrides);
   var wrappedExecute = function(toolCallId, params) {
     return (async function() {
       if (rateLimitEnabled) {
         var limiter = getRateLimiter(rlOpts);
-        var rlKey = agentId + ":" + tool.name;
+        var rlKey = agentId + ":" + tool2.name;
         if (!limiter.tryConsume(rlKey)) {
           var retryAfterMs = limiter.getRetryAfterMs(rlKey);
-          return errorResult("Rate limited: " + tool.name + ". Retry after " + retryAfterMs + "ms.");
+          return errorResult("Rate limited: " + tool2.name + ". Retry after " + retryAfterMs + "ms.");
         }
       }
       var traceId = requestId();
@@ -391,19 +391,19 @@ function wrapToolWithMiddleware(tool, config) {
       var result;
       try {
         if (useCircuitBreaker) {
-          var cb = getCircuitBreaker(tool.name);
+          var cb = getCircuitBreaker(tool2.name);
           try {
             result = await cb.execute(function() {
-              return tool.execute(toolCallId, params);
+              return tool2.execute(toolCallId, params);
             });
           } catch (err) {
             if (err instanceof CircuitOpenError) {
-              return errorResult("Circuit breaker open for " + tool.name + ". Service temporarily unavailable.");
+              return errorResult("Circuit breaker open for " + tool2.name + ". Service temporarily unavailable.");
             }
             throw err;
           }
         } else {
-          result = await tool.execute(toolCallId, params);
+          result = await tool2.execute(toolCallId, params);
         }
       } catch (err) {
         success = false;
@@ -420,7 +420,7 @@ function wrapToolWithMiddleware(tool, config) {
         );
         auditSink.log({
           traceId,
-          toolName: tool.name,
+          toolName: tool2.name,
           toolCallId,
           agentId,
           timestamp: new Date(startTime).toISOString(),
@@ -433,7 +433,7 @@ function wrapToolWithMiddleware(tool, config) {
       }
       if (telemetryEnabled && telemetrySink) {
         telemetrySink.record({
-          toolName: tool.name,
+          toolName: tool2.name,
           agentId,
           durationMs,
           success,
@@ -445,14 +445,14 @@ function wrapToolWithMiddleware(tool, config) {
     })();
   };
   return {
-    name: tool.name,
-    label: tool.label,
-    description: tool.description,
-    parameters: tool.parameters,
+    name: tool2.name,
+    label: tool2.label,
+    description: tool2.description,
+    parameters: tool2.parameters,
     execute: wrappedExecute,
-    ownerOnly: tool.ownerOnly,
-    category: tool.category,
-    risk: tool.risk
+    ownerOnly: tool2.ownerOnly,
+    category: tool2.category,
+    risk: tool2.risk
   };
 }
 function createToolMiddleware(config) {
@@ -492,17 +492,17 @@ function createToolMiddleware(config) {
     }
     return limiter;
   }
-  function wrap(tool) {
-    var useCircuitBreaker = cbEnabled && (tool.category === "web" || tool.category === "browser");
-    var rlOpts = resolveRateLimiterOpts(tool, config.rateLimit?.overrides);
+  function wrap(tool2) {
+    var useCircuitBreaker = cbEnabled && (tool2.category === "web" || tool2.category === "browser");
+    var rlOpts = resolveRateLimiterOpts(tool2, config.rateLimit?.overrides);
     var wrappedExecute = function(toolCallId, params) {
       return (async function() {
         if (rateLimitEnabled) {
           var limiter = getCachedRateLimiter(rlOpts);
-          var rlKey = agentId + ":" + tool.name;
+          var rlKey = agentId + ":" + tool2.name;
           if (!limiter.tryConsume(rlKey)) {
             var retryAfterMs = limiter.getRetryAfterMs(rlKey);
-            return errorResult("Rate limited: " + tool.name + ". Retry after " + retryAfterMs + "ms.");
+            return errorResult("Rate limited: " + tool2.name + ". Retry after " + retryAfterMs + "ms.");
           }
         }
         var traceId = requestId();
@@ -512,19 +512,19 @@ function createToolMiddleware(config) {
         var result;
         try {
           if (useCircuitBreaker) {
-            var cb = getLocalCircuitBreaker(tool.name);
+            var cb = getLocalCircuitBreaker(tool2.name);
             try {
               result = await cb.execute(function() {
-                return tool.execute(toolCallId, params);
+                return tool2.execute(toolCallId, params);
               });
             } catch (err) {
               if (err instanceof CircuitOpenError) {
-                return errorResult("Circuit breaker open for " + tool.name + ". Service temporarily unavailable.");
+                return errorResult("Circuit breaker open for " + tool2.name + ". Service temporarily unavailable.");
               }
               throw err;
             }
           } else {
-            result = await tool.execute(toolCallId, params);
+            result = await tool2.execute(toolCallId, params);
           }
         } catch (err) {
           success = false;
@@ -541,7 +541,7 @@ function createToolMiddleware(config) {
           );
           auditSink.log({
             traceId,
-            toolName: tool.name,
+            toolName: tool2.name,
             toolCallId,
             agentId,
             timestamp: new Date(startTime).toISOString(),
@@ -554,7 +554,7 @@ function createToolMiddleware(config) {
         }
         if (telemetryEnabled && telemetrySink) {
           telemetrySink.record({
-            toolName: tool.name,
+            toolName: tool2.name,
             agentId,
             durationMs,
             success,
@@ -566,14 +566,14 @@ function createToolMiddleware(config) {
       })();
     };
     return {
-      name: tool.name,
-      label: tool.label,
-      description: tool.description,
-      parameters: tool.parameters,
+      name: tool2.name,
+      label: tool2.label,
+      description: tool2.description,
+      parameters: tool2.parameters,
       execute: wrappedExecute,
-      ownerOnly: tool.ownerOnly,
-      category: tool.category,
-      risk: tool.risk
+      ownerOnly: tool2.ownerOnly,
+      category: tool2.category,
+      risk: tool2.risk
     };
   }
   function destroy() {
@@ -12336,6 +12336,582 @@ function createDiffTools(options) {
   return [entDiffText, entDiffJson, entDiffSpreadsheet, entDiffSummary];
 }
 
+// src/agent-tools/tools/remotion-video.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, writeFileSync, copyFileSync, readdirSync } from "fs";
+import { join, basename as basename2 } from "path";
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+function runInProject(projectDir, cmd, timeout = 12e4) {
+  return execSync(cmd, { cwd: projectDir, encoding: "utf-8", timeout, stdio: "pipe" }).trim();
+}
+function isRemotonInstalled(projectDir) {
+  return existsSync(join(projectDir, "node_modules", "remotion"));
+}
+var ROOT_INDEX_TSX = `import { registerRoot } from "remotion";
+import { RemotionRoot } from "./Root";
+registerRoot(RemotionRoot);
+`;
+var ROOT_TSX_TEMPLATE = (compositions) => `import { Composition } from "remotion";
+${compositions.map((c) => `import { ${pascalCase(c)} } from "./compositions/${c}";`).join("\n")}
+
+export const RemotionRoot: React.FC = () => {
+  return (
+    <>
+${compositions.map((c) => `      {/* @ts-ignore */}
+      <Composition id="${c}" component={${pascalCase(c)}} durationInFrames={450} fps={30} width={1080} height={1920} />`).join("\n")}
+    </>
+  );
+};
+`;
+function pascalCase(s) {
+  return s.replace(/(^|[-_])(\w)/g, (_, __, c) => c.toUpperCase());
+}
+var BLANK_COMPOSITION = (id) => `import { AbsoluteFill, useCurrentFrame, interpolate } from "remotion";
+
+export const ${pascalCase(id)}: React.FC<{ title?: string }> = ({ title = "Hello World" }) => {
+  const frame = useCurrentFrame();
+  const opacity = interpolate(frame, [0, 30], [0, 1], { extrapolateRight: "clamp" });
+
+  return (
+    <AbsoluteFill style={{ backgroundColor: "#0f0f0f", justifyContent: "center", alignItems: "center" }}>
+      <h1 style={{ color: "white", fontSize: 80, fontWeight: "bold", opacity, textAlign: "center", padding: 40 }}>
+        {title}
+      </h1>
+    </AbsoluteFill>
+  );
+};
+`;
+var TEXT_ANIMATION = (id) => `import { AbsoluteFill, useCurrentFrame, interpolate, spring, useVideoConfig, Sequence } from "remotion";
+
+const AnimatedText: React.FC<{ text: string; delay: number }> = ({ text, delay }) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+  const scale = spring({ frame: frame - delay, fps, config: { damping: 12 } });
+  const opacity = interpolate(frame - delay, [0, 15], [0, 1], { extrapolateLeft: "clamp", extrapolateRight: "clamp" });
+
+  return (
+    <div style={{ transform: \`scale(\${scale})\`, opacity, fontSize: 64, fontWeight: "bold", color: "white", textAlign: "center", padding: "0 40px" }}>
+      {text}
+    </div>
+  );
+};
+
+export const ${pascalCase(id)}: React.FC<{ lines?: string[] }> = ({ lines = ["Create", "Amazing", "Videos"] }) => {
+  const frame = useCurrentFrame();
+
+  return (
+    <AbsoluteFill style={{ backgroundColor: "#1a1a2e", justifyContent: "center", alignItems: "center", gap: 20 }}>
+      {lines.map((line, i) => (
+        <Sequence key={i} from={i * 20}>
+          <AnimatedText text={line} delay={0} />
+        </Sequence>
+      ))}
+    </AbsoluteFill>
+  );
+};
+`;
+var SLIDESHOW = (id) => `import { AbsoluteFill, useCurrentFrame, interpolate, Img, Sequence, useVideoConfig, staticFile } from "remotion";
+
+const Slide: React.FC<{ src: string; caption?: string }> = ({ src, caption }) => {
+  const frame = useCurrentFrame();
+  const opacity = interpolate(frame, [0, 15, 135, 150], [0, 1, 1, 0], { extrapolateLeft: "clamp", extrapolateRight: "clamp" });
+  const scale = interpolate(frame, [0, 150], [1, 1.05]);
+
+  return (
+    <AbsoluteFill style={{ opacity }}>
+      <Img src={src} style={{ width: "100%", height: "100%", objectFit: "cover", transform: \`scale(\${scale})\` }} />
+      {caption && (
+        <div style={{ position: "absolute", bottom: 80, left: 0, right: 0, textAlign: "center", color: "white", fontSize: 48, fontWeight: "bold", textShadow: "0 2px 20px rgba(0,0,0,0.8)", padding: "0 40px" }}>
+          {caption}
+        </div>
+      )}
+    </AbsoluteFill>
+  );
+};
+
+export const ${pascalCase(id)}: React.FC<{ slides?: Array<{ src: string; caption?: string }> }> = ({ slides = [] }) => {
+  const { fps } = useVideoConfig();
+  const slideDuration = fps * 5; // 5 seconds per slide
+
+  return (
+    <AbsoluteFill style={{ backgroundColor: "#000" }}>
+      {slides.map((slide, i) => (
+        <Sequence key={i} from={i * slideDuration} durationInFrames={slideDuration}>
+          <Slide src={slide.src} caption={slide.caption} />
+        </Sequence>
+      ))}
+    </AbsoluteFill>
+  );
+};
+`;
+var SOCIAL_REEL = (id) => `import { AbsoluteFill, useCurrentFrame, interpolate, spring, useVideoConfig, Sequence, Audio, staticFile } from "remotion";
+
+const HookText: React.FC<{ text: string }> = ({ text }) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+  const y = spring({ frame, fps, config: { damping: 15 } });
+  const translateY = interpolate(y, [0, 1], [100, 0]);
+
+  return (
+    <div style={{ transform: \`translateY(\${translateY}px)\`, fontSize: 56, fontWeight: 900, color: "white", textAlign: "center", padding: "0 50px", lineHeight: 1.3, textShadow: "0 2px 10px rgba(0,0,0,0.5)" }}>
+      {text}
+    </div>
+  );
+};
+
+const BodyPoint: React.FC<{ text: string; emoji?: string }> = ({ text, emoji = "\u2728" }) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+  const progress = spring({ frame, fps, config: { damping: 12, stiffness: 100 } });
+  const opacity = interpolate(progress, [0, 1], [0, 1]);
+  const x = interpolate(progress, [0, 1], [-50, 0]);
+
+  return (
+    <div style={{ opacity, transform: \`translateX(\${x}px)\`, fontSize: 36, color: "white", padding: "8px 50px", lineHeight: 1.5 }}>
+      {emoji} {text}
+    </div>
+  );
+};
+
+const CTA: React.FC<{ text: string; handle: string }> = ({ text, handle }) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+  const scale = spring({ frame, fps, config: { damping: 10, mass: 0.5 } });
+
+  return (
+    <div style={{ textAlign: "center", transform: \`scale(\${scale})\` }}>
+      <div style={{ fontSize: 40, fontWeight: 800, color: "#FFD700", marginBottom: 12 }}>{text}</div>
+      <div style={{ fontSize: 32, color: "rgba(255,255,255,0.8)" }}>{handle}</div>
+    </div>
+  );
+};
+
+export const ${pascalCase(id)}: React.FC<{
+  hook?: string;
+  points?: Array<{ text: string; emoji?: string }>;
+  cta?: string;
+  handle?: string;
+  bgColor?: string;
+  accentColor?: string;
+  audioSrc?: string;
+}> = ({
+  hook = "5 Signs You Need To Know",
+  points = [
+    { text: "They always make time for you", emoji: "\u{1F495}" },
+    { text: "They remember the small things", emoji: "\u{1F90D}" },
+    { text: "They support your growth", emoji: "\u{1F331}" },
+  ],
+  cta = "Follow for more",
+  handle = "@yourpage",
+  bgColor = "#1a1a2e",
+  accentColor = "#e94560",
+  audioSrc,
+}) => {
+  const { fps } = useVideoConfig();
+
+  return (
+    <AbsoluteFill style={{ background: \`linear-gradient(135deg, \${bgColor} 0%, \${accentColor}33 100%)\` }}>
+      {audioSrc && <Audio src={staticFile(audioSrc)} volume={0.5} />}
+
+      {/* Hook */}
+      <Sequence from={0} durationInFrames={fps * 3}>
+        <AbsoluteFill style={{ justifyContent: "center", alignItems: "center" }}>
+          <HookText text={hook} />
+          <div style={{ position: "absolute", bottom: 120, fontSize: 28, color: "rgba(255,255,255,0.6)" }}>
+            Check comments \u{1F447}
+          </div>
+        </AbsoluteFill>
+      </Sequence>
+
+      {/* Points */}
+      {points.map((point, i) => (
+        <Sequence key={i} from={fps * 3 + i * fps * 2.5} durationInFrames={fps * 2.5}>
+          <AbsoluteFill style={{ justifyContent: "center" }}>
+            <BodyPoint text={point.text} emoji={point.emoji} />
+          </AbsoluteFill>
+        </Sequence>
+      ))}
+
+      {/* CTA */}
+      <Sequence from={fps * 3 + points.length * fps * 2.5} durationInFrames={fps * 3}>
+        <AbsoluteFill style={{ justifyContent: "center", alignItems: "center" }}>
+          <CTA text={cta} handle={handle} />
+        </AbsoluteFill>
+      </Sequence>
+    </AbsoluteFill>
+  );
+};
+`;
+var TEMPLATES = {
+  "blank": BLANK_COMPOSITION,
+  "hello-world": BLANK_COMPOSITION,
+  "text-animation": TEXT_ANIMATION,
+  "slideshow": SLIDESHOW,
+  "social-reel": SOCIAL_REEL
+};
+var PACKAGE_JSON = (name) => JSON.stringify({
+  name: name || "remotion-project",
+  version: "1.0.0",
+  private: true,
+  scripts: {
+    start: "remotion studio",
+    build: "remotion render",
+    render: "remotion render"
+  },
+  dependencies: {
+    "@remotion/cli": "^4",
+    "@remotion/renderer": "^4",
+    "remotion": "^4",
+    "react": "^18",
+    "react-dom": "^18"
+  },
+  devDependencies: {
+    "@types/react": "^18",
+    "typescript": "^5"
+  }
+}, null, 2);
+var TSCONFIG = JSON.stringify({
+  compilerOptions: {
+    target: "ES2022",
+    module: "ES2022",
+    moduleResolution: "bundler",
+    jsx: "react-jsx",
+    strict: true,
+    skipLibCheck: true,
+    esModuleInterop: true,
+    outDir: "./dist"
+  },
+  include: ["src/**/*"]
+}, null, 2);
+var createProject = async (_id, params) => {
+  const { projectDir, name, template = "blank" } = params;
+  if (!projectDir) return { error: "projectDir is required" };
+  ensureDir(projectDir);
+  ensureDir(join(projectDir, "src", "compositions"));
+  ensureDir(join(projectDir, "public"));
+  writeFileSync(join(projectDir, "package.json"), PACKAGE_JSON(name || basename2(projectDir)));
+  writeFileSync(join(projectDir, "tsconfig.json"), TSCONFIG);
+  writeFileSync(join(projectDir, "src", "index.ts"), ROOT_INDEX_TSX);
+  const compId = "main";
+  const templateFn = TEMPLATES[template] || TEMPLATES["blank"];
+  writeFileSync(join(projectDir, "src", "compositions", `${compId}.tsx`), templateFn(compId));
+  writeFileSync(join(projectDir, "src", "Root.tsx"), ROOT_TSX_TEMPLATE([compId]));
+  try {
+    runInProject(projectDir, "npm install --no-audit --no-fund 2>&1", 18e4);
+  } catch (e) {
+    return {
+      success: true,
+      projectDir,
+      warning: `Project created but npm install failed: ${e.message?.substring(0, 200)}. Run \`cd ${projectDir} && npm install\` manually.`,
+      files: ["package.json", "tsconfig.json", "src/index.ts", "src/Root.tsx", `src/compositions/${compId}.tsx`]
+    };
+  }
+  return {
+    success: true,
+    projectDir,
+    template,
+    compositionId: compId,
+    files: ["package.json", "tsconfig.json", "src/index.ts", "src/Root.tsx", `src/compositions/${compId}.tsx`],
+    nextSteps: [
+      `Edit the composition: remotion_create_composition with your content`,
+      `Preview: remotion_preview_url to start the studio`,
+      `Render: remotion_render to create the video file`
+    ]
+  };
+};
+var createComposition = async (_id, params) => {
+  const { projectDir, compositionId, code, width = 1080, height = 1920, fps = 30, durationInSeconds = 15 } = params;
+  if (!projectDir || !compositionId || !code) return { error: "projectDir, compositionId, and code are required" };
+  if (!existsSync(projectDir)) return { error: `Project directory not found: ${projectDir}` };
+  const compDir = join(projectDir, "src", "compositions");
+  ensureDir(compDir);
+  const filePath = join(compDir, `${compositionId}.tsx`);
+  writeFileSync(filePath, code);
+  const compositions = readdirSync(compDir).filter((f) => f.endsWith(".tsx")).map((f) => f.replace(".tsx", ""));
+  const rootContent = `import { Composition } from "remotion";
+${compositions.map((c) => `import { ${pascalCase(c)} } from "./compositions/${c}";`).join("\n")}
+
+export const RemotionRoot: React.FC = () => {
+  return (
+    <>
+${compositions.map((c) => {
+    const isTarget = c === compositionId;
+    const w = isTarget ? width : 1080;
+    const h = isTarget ? height : 1920;
+    const f = isTarget ? fps : 30;
+    const dur = isTarget ? durationInSeconds * fps : 450;
+    return `      <Composition id="${c}" component={${pascalCase(c)}} durationInFrames={${dur}} fps={${f}} width={${w}} height={${h}} />`;
+  }).join("\n")}
+    </>
+  );
+};
+`;
+  writeFileSync(join(projectDir, "src", "Root.tsx"), rootContent);
+  return {
+    success: true,
+    compositionId,
+    filePath: `src/compositions/${compositionId}.tsx`,
+    dimensions: `${width}x${height}`,
+    fps,
+    duration: `${durationInSeconds}s (${durationInSeconds * fps} frames)`
+  };
+};
+var renderVideo = async (_id, params) => {
+  const { projectDir, compositionId, outputPath, codec = "h264", quality, inputProps, concurrency, scale } = params;
+  if (!projectDir || !compositionId || !outputPath) return { error: "projectDir, compositionId, and outputPath are required" };
+  if (!existsSync(projectDir)) return { error: `Project directory not found: ${projectDir}` };
+  if (!isRemotonInstalled(projectDir)) return { error: "Remotion not installed. Run remotion_create_project first or npm install in the project." };
+  const outDir = join(outputPath, "..");
+  ensureDir(outDir);
+  let cmd = `npx remotion render ${compositionId} "${outputPath}" --codec ${codec}`;
+  if (quality !== void 0) cmd += ` --crf ${quality}`;
+  if (concurrency) cmd += ` --concurrency ${concurrency}`;
+  if (scale && scale !== 1) cmd += ` --scale ${scale}`;
+  if (inputProps) {
+    const propsFile = join(projectDir, ".remotion-props.json");
+    writeFileSync(propsFile, JSON.stringify(inputProps));
+    cmd += ` --props "${propsFile}"`;
+  }
+  try {
+    const output = runInProject(projectDir, cmd, 6e5);
+    let shareUrl;
+    try {
+      const baseUrl = process.env.ENTERPRISE_URL || `http://localhost:${process.env.PORT || 8080}`;
+      const res = await fetch(`${baseUrl}/api/share-file`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ path: outputPath, ttl: 72 })
+        // 72 hour expiry
+      });
+      if (res.ok) {
+        const data = await res.json();
+        shareUrl = data.url;
+      }
+    } catch {
+    }
+    return {
+      success: true,
+      outputPath,
+      compositionId,
+      codec,
+      shareUrl,
+      message: shareUrl ? `Video rendered and available at: ${shareUrl}` : "Video rendered successfully",
+      output: output.substring(output.length - 500)
+    };
+  } catch (e) {
+    return {
+      error: `Render failed: ${e.message?.substring(0, 500)}`,
+      stderr: e.stderr?.substring(0, 500)
+    };
+  }
+};
+var renderStill = async (_id, params) => {
+  const { projectDir, compositionId, outputPath, frame = 0, inputProps, format = "png", scale } = params;
+  if (!projectDir || !compositionId || !outputPath) return { error: "projectDir, compositionId, and outputPath are required" };
+  if (!existsSync(projectDir)) return { error: `Project directory not found: ${projectDir}` };
+  if (!isRemotonInstalled(projectDir)) return { error: "Remotion not installed." };
+  ensureDir(join(outputPath, ".."));
+  let cmd = `npx remotion still ${compositionId} "${outputPath}" --frame ${frame} --image-format ${format}`;
+  if (scale && scale !== 1) cmd += ` --scale ${scale}`;
+  if (inputProps) {
+    const propsFile = join(projectDir, ".remotion-props.json");
+    writeFileSync(propsFile, JSON.stringify(inputProps));
+    cmd += ` --props "${propsFile}"`;
+  }
+  try {
+    runInProject(projectDir, cmd, 12e4);
+    return { success: true, outputPath, compositionId, frame, format };
+  } catch (e) {
+    return { error: `Still render failed: ${e.message?.substring(0, 500)}` };
+  }
+};
+var listCompositions = async (_id, params) => {
+  const { projectDir } = params;
+  if (!projectDir) return { error: "projectDir is required" };
+  if (!existsSync(projectDir)) return { error: `Project directory not found: ${projectDir}` };
+  const compDir = join(projectDir, "src", "compositions");
+  if (!existsSync(compDir)) return { compositions: [] };
+  const files = readdirSync(compDir).filter((f) => f.endsWith(".tsx") || f.endsWith(".jsx"));
+  const compositions = files.map((f) => ({
+    id: f.replace(/\.(tsx|jsx)$/, ""),
+    file: `src/compositions/${f}`
+  }));
+  return { compositions, projectDir };
+};
+var startPreview = async (_id, params) => {
+  const { projectDir, port = 3333 } = params;
+  if (!projectDir) return { error: "projectDir is required" };
+  if (!existsSync(projectDir)) return { error: `Project directory not found: ${projectDir}` };
+  if (!isRemotonInstalled(projectDir)) return { error: "Remotion not installed." };
+  try {
+    execSync(`cd "${projectDir}" && npx remotion studio --port ${port} &`, {
+      stdio: "ignore",
+      timeout: 5e3
+    });
+  } catch {
+  }
+  return {
+    success: true,
+    url: `http://localhost:${port}`,
+    message: `Remotion Studio starting on port ${port}. Open the URL in a browser to preview compositions.`
+  };
+};
+var addAsset = async (_id, params) => {
+  const { projectDir, source, filename } = params;
+  if (!projectDir || !source || !filename) return { error: "projectDir, source, and filename are required" };
+  const publicDir = join(projectDir, "public");
+  ensureDir(publicDir);
+  const destPath = join(publicDir, filename);
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    try {
+      execSync(`curl -sL -o "${destPath}" "${source}"`, { timeout: 6e4 });
+    } catch (e) {
+      return { error: `Failed to download asset: ${e.message?.substring(0, 200)}` };
+    }
+  } else if (existsSync(source)) {
+    copyFileSync(source, destPath);
+  } else {
+    return { error: `Source not found: ${source}` };
+  }
+  return {
+    success: true,
+    path: `public/${filename}`,
+    usage: `In your composition, use: staticFile("${filename}")`
+  };
+};
+var installPackage = async (_id, params) => {
+  const { projectDir, packages } = params;
+  if (!projectDir || !packages?.length) return { error: "projectDir and packages are required" };
+  if (!existsSync(projectDir)) return { error: `Project directory not found: ${projectDir}` };
+  const safePackages = packages.filter((p) => /^[@a-z0-9][\w./-]*$/.test(p));
+  if (safePackages.length === 0) return { error: "No valid package names provided" };
+  try {
+    const output = runInProject(projectDir, `npm install ${safePackages.join(" ")} --no-audit --no-fund 2>&1`, 12e4);
+    return { success: true, installed: safePackages, output: output.substring(output.length - 300) };
+  } catch (e) {
+    return { error: `Install failed: ${e.message?.substring(0, 300)}` };
+  }
+};
+var shareFile = async (_id, params) => {
+  const { filePath, ttl = 72 } = params;
+  if (!filePath) return { error: "filePath is required" };
+  if (!existsSync(filePath)) return { error: `File not found: ${filePath}` };
+  try {
+    const baseUrl = process.env.ENTERPRISE_URL || `http://localhost:${process.env.PORT || 8080}`;
+    const res = await fetch(`${baseUrl}/api/share-file`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: filePath, ttl })
+    });
+    if (!res.ok) return { error: `Share failed: ${res.status}` };
+    const data = await res.json();
+    return { success: true, url: data.url, expiresIn: data.expiresIn, message: `File available at: ${data.url}` };
+  } catch (e) {
+    return { error: `Share failed: ${e.message?.substring(0, 300)}` };
+  }
+};
+function tool(name, label, description, params, executor) {
+  return {
+    name,
+    label,
+    description,
+    category: "media",
+    risk: "medium",
+    parameters: params,
+    execute: async (_id, args) => executor(_id, args)
+  };
+}
+function createRemotonTools() {
+  return [
+    tool("remotion_create_project", "Create Video Project", "Initialize a new Remotion video project with templates (blank, text-animation, slideshow, social-reel).", {
+      type: "object",
+      properties: {
+        projectDir: { type: "string", description: "Directory for the project" },
+        name: { type: "string", description: "Project name" },
+        template: { type: "string", enum: ["blank", "hello-world", "text-animation", "slideshow", "social-reel"], description: "Starter template" }
+      },
+      required: ["projectDir"]
+    }, createProject),
+    tool("remotion_create_composition", "Create Video Composition", "Create or update a Remotion composition (React component) that defines video content. Use React + Remotion APIs: useCurrentFrame(), interpolate(), spring(), Sequence, AbsoluteFill.", {
+      type: "object",
+      properties: {
+        projectDir: { type: "string", description: "Project directory" },
+        compositionId: { type: "string", description: "Unique composition ID" },
+        code: { type: "string", description: "Full React/TSX component code" },
+        width: { type: "number", default: 1080 },
+        height: { type: "number", default: 1920 },
+        fps: { type: "number", default: 30 },
+        durationInSeconds: { type: "number", default: 15 }
+      },
+      required: ["projectDir", "compositionId", "code"]
+    }, createComposition),
+    tool("remotion_render", "Render Video", "Render a composition to MP4/WebM/GIF. Requires ffmpeg.", {
+      type: "object",
+      properties: {
+        projectDir: { type: "string" },
+        compositionId: { type: "string" },
+        outputPath: { type: "string" },
+        codec: { type: "string", enum: ["h264", "h265", "vp8", "vp9", "gif", "prores"], default: "h264" },
+        quality: { type: "number" },
+        inputProps: { type: "object" },
+        concurrency: { type: "number" },
+        scale: { type: "number" }
+      },
+      required: ["projectDir", "compositionId", "outputPath"]
+    }, renderVideo),
+    tool("remotion_render_still", "Render Still Image", "Render a single frame as PNG/JPEG for thumbnails or previews.", {
+      type: "object",
+      properties: {
+        projectDir: { type: "string" },
+        compositionId: { type: "string" },
+        outputPath: { type: "string" },
+        frame: { type: "number", default: 0 },
+        inputProps: { type: "object" },
+        format: { type: "string", enum: ["png", "jpeg", "webp"], default: "png" },
+        scale: { type: "number" }
+      },
+      required: ["projectDir", "compositionId", "outputPath"]
+    }, renderStill),
+    tool("remotion_list_compositions", "List Compositions", "List all compositions in a Remotion project.", {
+      type: "object",
+      properties: { projectDir: { type: "string" } },
+      required: ["projectDir"]
+    }, listCompositions),
+    tool("remotion_preview_url", "Start Preview Server", "Start Remotion Studio to preview compositions in browser.", {
+      type: "object",
+      properties: { projectDir: { type: "string" }, port: { type: "number", default: 3333 } },
+      required: ["projectDir"]
+    }, startPreview),
+    tool("remotion_add_asset", "Add Asset", "Add image/audio/video/font asset to project public/ directory from URL or local path.", {
+      type: "object",
+      properties: {
+        projectDir: { type: "string" },
+        source: { type: "string", description: "URL or local path" },
+        filename: { type: "string", description: "Filename in public/" }
+      },
+      required: ["projectDir", "source", "filename"]
+    }, addAsset),
+    tool("remotion_install_package", "Install Remotion Package", "Install additional packages: @remotion/transitions, @remotion/motion-blur, @remotion/shapes, @remotion/lottie, @remotion/three, etc.", {
+      type: "object",
+      properties: {
+        projectDir: { type: "string" },
+        packages: { type: "array", items: { type: "string" } }
+      },
+      required: ["projectDir", "packages"]
+    }, installPackage),
+    tool("remotion_share_file", "Share File via URL", "Generate a shareable URL for any file (video, image, PDF, etc.). The URL is publicly accessible for a limited time (default 72 hours). Use this to share rendered videos with users via messaging channels.", {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Absolute path to the file to share" },
+        ttl: { type: "number", default: 72, description: "Hours until the link expires (default 72)" }
+      },
+      required: ["filePath"]
+    }, shareFile)
+  ];
+}
+
 // src/agent-tools/index.ts
 init_whatsapp();
 init_telegram();
@@ -13692,6 +14268,7 @@ async function createAllTools(options) {
     ...createSecurityScanTools(options),
     ...createCodeSandboxTools(options),
     ...createDiffTools(options),
+    ...createRemotonTools(),
     ...createKnowledgeSearchTools(options || {})
   ];
   var agenticmailTools = [];
@@ -13936,8 +14513,8 @@ async function createAllTools(options) {
       circuitBreaker: options.middleware.circuitBreaker,
       telemetry: options.middleware.telemetry
     });
-    enabledTools = enabledTools.map(function(tool) {
-      return mw.wrap(tool);
+    enabledTools = enabledTools.map(function(tool2) {
+      return mw.wrap(tool2);
     });
   }
   return enabledTools;
@@ -13974,6 +14551,7 @@ export {
   createMemoryTools,
   createPathSandbox,
   createReadTool,
+  createRemotonTools,
   createSecurityScanTools,
   createSpreadsheetTools,
   createSsrfGuard,