apteva 0.4.41 → 0.4.44

package/src/openapi.ts

@@ -1006,6 +1006,40 @@ while (true) {
         },
       },
     },
+    "/tasks/{agentId}": {
+      post: {
+        tags: ["Tasks"],
+        summary: "Create a task on an agent",
+        description: "Create a new task on a running agent. The agent must have the tasks feature enabled.",
+        parameters: [
+          { name: "agentId", in: "path", required: true, schema: { type: "string" }, description: "Agent ID to create the task on" },
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  title: { type: "string", description: "Task title" },
+                  description: { type: "string", description: "Task description" },
+                  type: { type: "string", enum: ["once", "recurring"], default: "once" },
+                  priority: { type: "integer", minimum: 1, maximum: 10, default: 5 },
+                  execute_at: { type: "string", format: "date-time", description: "Scheduled execution time (for one-time tasks)" },
+                  recurrence: { type: "string", description: "Cron expression (for recurring tasks)" },
+                },
+                required: ["title"],
+              },
+            },
+          },
+        },
+        responses: {
+          "201": { description: "Task created successfully" },
+          "400": { description: "Agent is not running or invalid input" },
+          "404": { description: "Agent not found" },
+        },
+      },
+    },
     "/tasks/{agentId}/{taskId}": {
       get: {
         tags: ["Tasks"],
@@ -1033,6 +1067,68 @@ while (true) {
           "404": { description: "Agent not found" },
         },
       },
+      put: {
+        tags: ["Tasks"],
+        summary: "Update a task on an agent",
+        description: "Update an existing task on a running agent.",
+        parameters: [
+          { name: "agentId", in: "path", required: true, schema: { type: "string" }, description: "Agent ID" },
+          { name: "taskId", in: "path", required: true, schema: { type: "string" }, description: "Task ID to update" },
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  title: { type: "string" },
+                  description: { type: "string" },
+                  type: { type: "string", enum: ["once", "recurring"] },
+                  priority: { type: "integer", minimum: 1, maximum: 10 },
+                  execute_at: { type: "string", format: "date-time" },
+                  recurrence: { type: "string" },
+                },
+              },
+            },
+          },
+        },
+        responses: {
+          "200": { description: "Task updated" },
+          "400": { description: "Agent is not running or invalid input" },
+          "404": { description: "Agent or task not found" },
+        },
+      },
+      delete: {
+        tags: ["Tasks"],
+        summary: "Delete a task on an agent",
+        description: "Delete a task from a running agent.",
+        parameters: [
+          { name: "agentId", in: "path", required: true, schema: { type: "string" }, description: "Agent ID" },
+          { name: "taskId", in: "path", required: true, schema: { type: "string" }, description: "Task ID to delete" },
+        ],
+        responses: {
+          "200": { description: "Task deleted" },
+          "400": { description: "Agent is not running" },
+          "404": { description: "Agent or task not found" },
+        },
+      },
+    },
+    "/tasks/{agentId}/{taskId}/execute": {
+      post: {
+        tags: ["Tasks"],
+        summary: "Execute a task immediately",
+        description: "Immediately execute a task on a running agent, regardless of its schedule.",
+        parameters: [
+          { name: "agentId", in: "path", required: true, schema: { type: "string" }, description: "Agent ID" },
+          { name: "taskId", in: "path", required: true, schema: { type: "string" }, description: "Task ID to execute" },
+        ],
+        responses: {
+          "200": { description: "Task execution started" },
+          "400": { description: "Agent is not running" },
+          "404": { description: "Agent or task not found" },
+        },
+      },
     },
     "/mcp/servers": {
       get: {

package/src/providers.ts

@@ -12,9 +12,9 @@ export const PROVIDERS = {
     docsUrl: "https://console.anthropic.com/settings/keys",
     testEndpoint: "https://api.anthropic.com/v1/messages",
     models: [
-      { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", recommended: true },
-      { value: "claude-sonnet-4-5", label: "Claude Sonnet 4.5" },
-      { value: "claude-haiku-4-5", label: "Claude Haiku 4.5 (Fast)" },
+      { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", recommended: true, input_cost: 3, output_cost: 15 },
+      { value: "claude-sonnet-4-5", label: "Claude Sonnet 4.5", input_cost: 3, output_cost: 15 },
+      { value: "claude-haiku-4-5", label: "Claude Haiku 4.5 (Fast)", input_cost: 0.8, output_cost: 4 },
     ],
   },
   openai: {
@@ -26,8 +26,8 @@ export const PROVIDERS = {
     docsUrl: "https://platform.openai.com/api-keys",
     testEndpoint: "https://api.openai.com/v1/models",
     models: [
-      { value: "gpt-4o", label: "GPT-4o", recommended: true },
-      { value: "gpt-4o-mini", label: "GPT-4o Mini (Fast)" },
+      { value: "gpt-4o", label: "GPT-4o", recommended: true, input_cost: 2.5, output_cost: 10 },
+      { value: "gpt-4o-mini", label: "GPT-4o Mini (Fast)", input_cost: 0.15, output_cost: 0.6 },
     ],
   },
   groq: {
@@ -39,8 +39,8 @@ export const PROVIDERS = {
     docsUrl: "https://console.groq.com/keys",
     testEndpoint: "https://api.groq.com/openai/v1/models",
     models: [
-      { value: "llama-3.3-70b-versatile", label: "Llama 3.3 70B", recommended: true },
-      { value: "llama-3.1-8b-instant", label: "Llama 3.1 8B (Fast)" },
+      { value: "llama-3.3-70b-versatile", label: "Llama 3.3 70B", recommended: true, input_cost: 0, output_cost: 0 },
+      { value: "llama-3.1-8b-instant", label: "Llama 3.1 8B (Fast)", input_cost: 0, output_cost: 0 },
     ],
   },
   gemini: {
@@ -52,8 +52,8 @@ export const PROVIDERS = {
     docsUrl: "https://aistudio.google.com/app/apikey",
     testEndpoint: "https://generativelanguage.googleapis.com/v1/models",
     models: [
-      { value: "gemini-3-pro-preview", label: "Gemini 3 Pro Preview (Latest)", recommended: true },
-      { value: "gemini-3-flash-preview", label: "Gemini 3 Flash Preview (Fast)" },
+      { value: "gemini-3-pro-preview", label: "Gemini 3 Pro Preview (Latest)", recommended: true, input_cost: 2, output_cost: 12 },
+      { value: "gemini-3-flash-preview", label: "Gemini 3 Flash Preview (Fast)", input_cost: 0.5, output_cost: 3 },
     ],
   },
   xai: {
@@ -65,8 +65,8 @@ export const PROVIDERS = {
     docsUrl: "https://console.x.ai/",
     testEndpoint: "https://api.x.ai/v1/models",
     models: [
-      { value: "grok-2", label: "Grok 2", recommended: true },
-      { value: "grok-2-mini", label: "Grok 2 Mini (Fast)" },
+      { value: "grok-2", label: "Grok 2", recommended: true, input_cost: 2, output_cost: 10 },
+      { value: "grok-2-mini", label: "Grok 2 Mini (Fast)", input_cost: 0.3, output_cost: 1 },
     ],
   },
   together: {
@@ -78,8 +78,8 @@ export const PROVIDERS = {
     docsUrl: "https://api.together.xyz/settings/api-keys",
     testEndpoint: "https://api.together.xyz/v1/models",
     models: [
-      { value: "moonshotai/Kimi-K2.5", label: "Kimi K2.5", recommended: true },
-      { value: "moonshotai/Kimi-K2-Thinking", label: "Kimi K2 Thinking (Reasoning)" },
+      { value: "moonshotai/Kimi-K2.5", label: "Kimi K2.5", recommended: true, input_cost: 1, output_cost: 4 },
+      { value: "moonshotai/Kimi-K2-Thinking", label: "Kimi K2 Thinking (Reasoning)", input_cost: 1, output_cost: 4 },
     ],
   },
   fireworks: {
@@ -91,10 +91,10 @@ export const PROVIDERS = {
     docsUrl: "https://fireworks.ai/api-keys",
     testEndpoint: "https://api.fireworks.ai/inference/v1/models",
     models: [
-      { value: "accounts/fireworks/models/kimi-k2p5", label: "Kimi K2.5", recommended: true },
-      { value: "accounts/fireworks/models/kimi-k2-thinking", label: "Kimi K2 Thinking (Reasoning)" },
-      { value: "accounts/fireworks/models/minimax-m2p5", label: "MiniMax M2.5" },
-      { value: "accounts/fireworks/models/glm-5", label: "GLM 5" },
+      { value: "accounts/fireworks/models/kimi-k2p5", label: "Kimi K2.5", recommended: true, input_cost: 1, output_cost: 4 },
+      { value: "accounts/fireworks/models/kimi-k2-thinking", label: "Kimi K2 Thinking (Reasoning)", input_cost: 1, output_cost: 4 },
+      { value: "accounts/fireworks/models/minimax-m2p5", label: "MiniMax M2.5", input_cost: 1, output_cost: 4 },
+      { value: "accounts/fireworks/models/glm-5", label: "GLM 5", input_cost: 1, output_cost: 4 },
     ],
   },
   moonshot: {
@@ -106,8 +106,24 @@ export const PROVIDERS = {
     docsUrl: "https://platform.moonshot.cn/console/api-keys",
     testEndpoint: "https://api.moonshot.cn/v1/models",
     models: [
-      { value: "moonshot-v1-128k", label: "Kimi 128K", recommended: true },
-      { value: "moonshot-v1-32k", label: "Kimi 32K (Fast)" },
+      { value: "moonshot-v1-128k", label: "Kimi 128K", recommended: true, input_cost: 1, output_cost: 4 },
+      { value: "moonshot-v1-32k", label: "Kimi 32K (Fast)", input_cost: 0.5, output_cost: 2 },
+    ],
+  },
+  venice: {
+    id: "venice",
+    name: "Venice",
+    displayName: "Venice AI",
+    type: "llm" as const,
+    envVar: "VENICE_API_KEY",
+    docsUrl: "https://docs.venice.ai/overview/pricing",
+    testEndpoint: "https://api.venice.ai/api/v1/models",
+    models: [
+      { value: "llama-3.3-70b", label: "Llama 3.3 70B", recommended: true, input_cost: 0.7, output_cost: 2.8 },
+      { value: "olafangensan-glm-4.7-flash-heretic", label: "GLM 4.7 Flash Heretic", input_cost: 0.14, output_cost: 0.8 },
+      { value: "qwen3-235b-a22b-instruct-2507", label: "Qwen 3 235B Instruct", input_cost: 0.15, output_cost: 0.75 },
+      { value: "deepseek-v3.2", label: "DeepSeek V3.2", input_cost: 0.4, output_cost: 1 },
+      { value: "venice-uncensored", label: "Venice Uncensored 1.1", input_cost: 0.2, output_cost: 0.9 },
     ],
   },
   ollama: {
@@ -122,11 +138,11 @@ export const PROVIDERS = {
     defaultBaseUrl: "http://localhost:11434",
     models: [
       // Default models - actual list fetched dynamically from Ollama
-      { value: "llama3.3", label: "Llama 3.3 (70B)", recommended: true },
-      { value: "llama3.2", label: "Llama 3.2 (3B)" },
-      { value: "qwen2.5", label: "Qwen 2.5" },
-      { value: "mistral", label: "Mistral" },
-      { value: "deepseek-r1", label: "DeepSeek R1" },
+      { value: "llama3.3", label: "Llama 3.3 (70B)", recommended: true, input_cost: 0, output_cost: 0 },
+      { value: "llama3.2", label: "Llama 3.2 (3B)", input_cost: 0, output_cost: 0 },
+      { value: "qwen2.5", label: "Qwen 2.5", input_cost: 0, output_cost: 0 },
+      { value: "mistral", label: "Mistral", input_cost: 0, output_cost: 0 },
+      { value: "deepseek-r1", label: "DeepSeek R1", input_cost: 0, output_cost: 0 },
     ],
   },
   // Browser Providers
@@ -217,6 +233,16 @@ export const PROVIDERS = {
 
 export type ProviderId = keyof typeof PROVIDERS;
 
+/** Get cost per 1M tokens for a given provider + model. Returns { input_cost, output_cost } in USD. */
+export function getModelCost(provider: string, model: string): { input_cost: number; output_cost: number } {
+  const providerDef = PROVIDERS[provider as ProviderId];
+  if (!providerDef || !("models" in providerDef)) return { input_cost: 0, output_cost: 0 };
+  const modelDef = (providerDef.models as ReadonlyArray<{ value: string; input_cost?: number; output_cost?: number }>)
+    .find(m => m.value === model);
+  if (!modelDef) return { input_cost: 0, output_cost: 0 };
+  return { input_cost: modelDef.input_cost ?? 0, output_cost: modelDef.output_cost ?? 0 };
+}
+
 // Provider Keys Management
 export const ProviderKeys = {
   // Save an API key (encrypts before storing)

package/src/routes/api/agent-utils.ts

@@ -337,7 +337,6 @@ export function buildAgentConfig(agent: Agent, providerKey: string) {
       const baseUrl = process.env.PUBLIC_URL || `http://localhost:${process.env.PORT || 4280}`;
       return {
         enabled: multiAgentConfig.enabled,
-        mode: multiAgentConfig.mode || "worker",
         group: multiAgentConfig.group || agent.project_id || undefined,
         // This agent's reachable URL for peer communication
         url: `http://localhost:${agent.port}`,

package/src/routes/api/agents.ts

@@ -270,6 +270,25 @@ export async function handleAgentRoutes(
     });
   }
 
+  // ==================== SHARE LINK ====================
+
+  // GET /api/agents/:id/share-token - Get the share token for this agent
+  const shareTokenMatch = path.match(/^\/api\/agents\/([^/]+)\/share-token$/);
+  if (shareTokenMatch && method === "GET") {
+    const agent = AgentDB.findById(shareTokenMatch[1]);
+    if (!agent) {
+      return json({ error: "Agent not found" }, 404);
+    }
+
+    const { getShareToken } = await import("../share");
+    const token = getShareToken(agent.id);
+    if (!token) {
+      return json({ error: "Could not generate share token" }, 500);
+    }
+
+    return json({ token });
+  }
+
   // ==================== AGENT LIFECYCLE ====================
 
   // POST /api/agents/:id/start - Start an agent
@@ -840,7 +859,6 @@ export async function handleAgentRoutes(
           id: a.id,
           name: a.name,
           url: `http://localhost:${a.port}`,
-          mode: agentConfig.mode || "worker",
           group: agentConfig.group || a.project_id,
         };
       });

package/src/routes/api/meta-agent.ts

@@ -117,6 +117,8 @@ Be concise. Use markdown formatting.`,
         port: metaAgent.port,
         provider: metaAgent.provider,
         model: metaAgent.model,
+        features: metaAgent.features,
+        systemPrompt: metaAgent.system_prompt,
       },
     });
   }

package/src/routes/api/system.ts

@@ -1,5 +1,5 @@
 import { json } from "./helpers";
-import { META_AGENT_ENABLED, fetchFromAgent, startAgentProcess, setAgentStatus } from "./agent-utils";
+import { META_AGENT_ENABLED, fetchFromAgent, agentFetch, startAgentProcess, setAgentStatus } from "./agent-utils";
 import { AgentDB } from "../../db";
 import { ProviderKeys } from "../../providers";
 import { agentProcesses, getBinaryStatus, BIN_DIR } from "../../server";
@@ -44,6 +44,7 @@ export async function handleSystemRoutes(
     return json({
       projects: process.env.PROJECTS_ENABLED === "true",
       metaAgent: process.env.META_AGENT_ENABLED === "true",
+      costTracking: process.env.COST_TRACKING_ENABLED !== "false",
     });
   }
 
@@ -180,6 +181,94 @@ export async function handleSystemRoutes(
     return json({ task: { ...data, agentId: agent.id, agentName: agent.name } });
   }
 
+  // POST /api/tasks/:agentId/:taskId/execute - Execute a task immediately
+  const executeTaskMatch = path.match(/^\/api\/tasks\/([^/]+)\/([^/]+)\/execute$/);
+  if (executeTaskMatch && method === "POST") {
+    const [, agentId, taskId] = executeTaskMatch;
+    const agent = AgentDB.findById(agentId);
+    if (!agent) return json({ error: "Agent not found" }, 404);
+    if (agent.status !== "running" || !agent.port) return json({ error: "Agent is not running" }, 400);
+
+    try {
+      const res = await agentFetch(agentId, agent.port, `/tasks/${taskId}/execute`, {
+        method: "POST",
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json();
+      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
+      return json(data);
+    } catch (err) {
+      return json({ error: `Failed to execute task: ${err}` }, 500);
+    }
+  }
+
+  // POST /api/tasks/:agentId - Create a task on an agent
+  const createTaskMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
+  if (createTaskMatch && method === "POST") {
+    const agentId = createTaskMatch[1];
+    const agent = AgentDB.findById(agentId);
+    if (!agent) return json({ error: "Agent not found" }, 404);
+    if (agent.status !== "running" || !agent.port) return json({ error: "Agent is not running" }, 400);
+
+    try {
+      const body = await req.json();
+      const res = await agentFetch(agentId, agent.port, "/tasks", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json();
+      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
+      return json(data, 201);
+    } catch (err) {
+      return json({ error: `Failed to create task: ${err}` }, 500);
+    }
+  }
+
+  // PUT /api/tasks/:agentId/:taskId - Update a task on an agent
+  if (singleTaskMatch && method === "PUT") {
+    const [, agentId, taskId] = singleTaskMatch;
+    const agent = AgentDB.findById(agentId);
+    if (!agent) return json({ error: "Agent not found" }, 404);
+    if (agent.status !== "running" || !agent.port) return json({ error: "Agent is not running" }, 400);
+
+    try {
+      const body = await req.json();
+      const res = await agentFetch(agentId, agent.port, `/tasks/${taskId}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json();
+      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
+      return json(data);
+    } catch (err) {
+      return json({ error: `Failed to update task: ${err}` }, 500);
+    }
+  }
+
+  // DELETE /api/tasks/:agentId/:taskId - Delete a task on an agent
+  if (singleTaskMatch && method === "DELETE") {
+    const [, agentId, taskId] = singleTaskMatch;
+    const agent = AgentDB.findById(agentId);
+    if (!agent) return json({ error: "Agent not found" }, 404);
+    if (agent.status !== "running" || !agent.port) return json({ error: "Agent is not running" }, 400);
+
+    try {
+      const res = await agentFetch(agentId, agent.port, `/tasks/${taskId}`, {
+        method: "DELETE",
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json();
+      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
+      return json(data);
+    } catch (err) {
+      return json({ error: `Failed to delete task: ${err}` }, 500);
+    }
+  }
+
   // GET /api/dashboard - Get dashboard statistics
   if (path === "/api/dashboard" && method === "GET") {
     const url = new URL(req.url);

package/src/routes/api/telemetry.ts

@@ -1,5 +1,6 @@
 import { json } from "./helpers";
-import { TelemetryDB } from "../../db";
+import { TelemetryDB, AgentDB } from "../../db";
+import { getModelCost } from "../../providers";
 import { telemetryBroadcaster, type TelemetryEvent } from "../../server";
 
 export async function handleTelemetryRoutes(
@@ -35,6 +36,23 @@ export async function handleTelemetryRoutes(
 
       // Filter out debug events - too noisy
       const filteredEvents = body.events.filter(e => e.level !== "debug");
+
+      // Compute cost per LLM event if cost tracking is enabled
+      const costTrackingEnabled = process.env.COST_TRACKING_ENABLED !== "false";
+      if (costTrackingEnabled) {
+        const agent = AgentDB.findById(body.agent_id);
+        if (agent) {
+          const pricing = getModelCost(agent.provider, agent.model);
+          for (const event of filteredEvents) {
+            if (event.category === "LLM" && event.data) {
+              const inputTokens = (event.data.input_tokens as number) || 0;
+              const outputTokens = (event.data.output_tokens as number) || 0;
+              (event as any).cost = (inputTokens * pricing.input_cost + outputTokens * pricing.output_cost) / 1_000_000;
+            }
+          }
+        }
+      }
+
       const inserted = TelemetryDB.insertBatch(body.agent_id, filteredEvents);
 
       // Broadcast to SSE clients

package/src/routes/share.ts

@@ -0,0 +1,85 @@
+import { createHash } from "crypto";
+import { AgentDB, type Agent } from "../db";
+import { agentFetch } from "./api/agent-utils";
+
+function deriveShareToken(apiKey: string, agentId: string): string {
+  return createHash("sha256")
+    .update(apiKey + ":" + agentId + ":share")
+    .digest("hex")
+    .substring(0, 32);
+}
+
+function findAgentByShareToken(token: string): Agent | null {
+  const agents = AgentDB.findAll();
+  for (const agent of agents) {
+    const apiKey = AgentDB.getApiKey(agent.id);
+    if (!apiKey) continue;
+    if (deriveShareToken(apiKey, agent.id) === token) return agent;
+  }
+  return null;
+}
+
+/** Get the share token for an agent (used by API route for the UI) */
+export function getShareToken(agentId: string): string | null {
+  const apiKey = AgentDB.getApiKey(agentId);
+  if (!apiKey) return null;
+  return deriveShareToken(apiKey, agentId);
+}
+
+export async function handleShareRequest(req: Request, path: string): Promise<Response | null> {
+  // Match /share/<32 hex chars> sub-paths for API calls
+  const infoMatch = path.match(/^\/share\/([a-f0-9]{32})\/info$/);
+  const chatMatch = path.match(/^\/share\/([a-f0-9]{32})\/chat$/);
+
+  if (!infoMatch && !chatMatch) return null;
+
+  const token = (infoMatch || chatMatch)![1];
+  const agent = findAgentByShareToken(token);
+
+  // Intentionally vague 404 — don't reveal whether token exists
+  if (!agent) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  // GET /share/:token/info — agent info (no secrets)
+  if (infoMatch && req.method === "GET") {
+    return Response.json({
+      name: agent.name,
+      status: agent.status,
+    });
+  }
+
+  // POST /share/:token/chat — proxy to agent
+  if (chatMatch && req.method === "POST") {
+    if (agent.status !== "running" || !agent.port) {
+      return Response.json({ error: "Agent is currently offline" }, { status: 503 });
+    }
+
+    try {
+      const body = await req.json();
+      const response = await agentFetch(agent.id, agent.port, "/chat", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return Response.json({ error: `Agent error: ${errorText}` }, { status: response.status });
+      }
+
+      return new Response(response.body, {
+        status: 200,
+        headers: {
+          "Content-Type": response.headers.get("Content-Type") || "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+        },
+      });
+    } catch (err) {
+      return Response.json({ error: "Failed to connect to agent" }, { status: 500 });
+    }
+  }
+
+  return null;
+}

package/src/server.ts

@@ -1,6 +1,7 @@
 import { type Server, type Subprocess } from "bun";
 import { handleApiRequest } from "./routes/api";
 import { handleAuthRequest } from "./routes/auth";
+import { handleShareRequest } from "./routes/share";
 import { serveStatic } from "./routes/static";
 import { join } from "path";
 import { homedir } from "os";
@@ -421,6 +422,17 @@ const server = Bun.serve({
       return response;
     }
 
+    // Share routes (public, token-authenticated)
+    if (path.startsWith("/share/")) {
+      const shareResponse = await handleShareRequest(req, path);
+      if (shareResponse) {
+        Object.entries(corsHeaders).forEach(([key, value]) => {
+          shareResponse.headers.set(key, value);
+        });
+        return shareResponse;
+      }
+    }
+
     // Serve static files (React app)
     return serveStatic(req, path);
   },