ofiere-openclaw-plugin 4.15.0 → 4.17.0

package/README.md

@@ -5,7 +5,7 @@ Manage your Ofiere PM dashboard directly from OpenClaw agents. Create tasks, man
 ## Quick Install (One-Click)
 
 ```bash
-curl -sSL https://raw.githubusercontent.com/gilanggemar/Ofiere/main/ofiere-openclaw-plugin/install.sh | bash -s -- \
+curl -sSL https://ofiere.com/scripts/install.sh | bash -s -- \
   --supabase-url "https://xxx.supabase.co" \
   --service-key "eyJ..." \
   --user-id "your-uuid"
@@ -16,7 +16,7 @@ Only 3 parameters needed. All agents get the plugin automatically.
 ## Uninstall
 
 ```bash
-curl -sSL https://raw.githubusercontent.com/gilanggemar/Ofiere/main/ofiere-openclaw-plugin/uninstall.sh | bash
+curl -sSL https://ofiere.com/scripts/uninstall.sh | bash
 ```
 
 ## How It Works

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.15.0",
+  "version": "4.17.0",
   "type": "module",
   "description": "OpenClaw plugin for Ofiere PM - 11 meta-tools covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, constellation, and space file management",
   "keywords": ["openclaw", "ofiere", "project-management", "agents", "plugin"],

package/src/prompt.ts

@@ -62,10 +62,19 @@ const TOOL_DOCS: Record<string, string> = {
     - Edge handles: condition edges use sourceHandle "condition-true"/"condition-false". Loop edges use "loop_body"/"done"
     - Variables: Use {{prev.nodeId.outputText}} for prior outputs, {{variables.key}} for stored variables`,
 
-  OFIERE_NOTIFY_OPS: `- **OFIERE_NOTIFY_OPS** — Notifications (action: "list", "mark_read", "mark_all_read", "delete")
+  OFIERE_NOTIFY_OPS: `- **OFIERE_NOTIFY_OPS** — Notifications & Channel Reports (action: "list", "mark_read", "mark_all_read", "delete", "send_report", "schedule_report", "list_schedules", "delete_schedule")
     - list: Recent notifications. unread_only=true for unread only
     - mark_read: Mark one notification read by ID
-    - mark_all_read: Mark all as read`,
+    - mark_all_read: Mark all as read
+    - send_report: Send a PM progress report to YOUR connected channels (Telegram, Discord, Slack, etc.)
+      - Required: scope_type (space|folder|project|task|all)
+      - Optional: scope_id, channel_types[] (filter to specific channels), include_completed
+      - The report is automatically generated from current PM data and sent through YOUR channel bindings ONLY
+    - schedule_report: Create a recurring/scheduled report
+      - Required: scope_type, recurrence_type (hourly|daily|weekly|monthly)
+      - Optional: scope_id, scope_label, channel_types[], recurrence_time (HH:MM UTC, default 09:00), recurrence_interval, recurrence_days_of_week (e.g. "mon,wed,fri"), include_completed
+    - list_schedules: View all your active report schedules
+    - delete_schedule: Remove a scheduled report by schedule_id`,
 
   OFIERE_MEMORY_OPS: `- **OFIERE_MEMORY_OPS** — Conversation history & knowledge memory (action: "list_conversations", "get_messages", "search_messages", "add_knowledge", "search_knowledge")
     - list_conversations: Recent chats, filter by agent_id
@@ -165,6 +174,9 @@ ${toolDocs}
 - When task instructions or system prompts contain file references like @[filename](file:FILE_ID), use OFIERE_FILE_OPS action:"read_text_file" file_id:"FILE_ID" to read the file content. Do NOT ask the user for the file — retrieve it yourself.
 - Use OFIERE_FILE_OPS to create output files (reports, data, configs) in the Space Files explorer. Prefer create_text_file for text-based outputs.
 - To save task output as a file, call OFIERE_FILE_OPS action:"create_text_file" with the space_id from the task context.
+- CHANNEL REPORTS: When the user asks you to "send a report", "send progress", "update me on Telegram/Discord/Slack/WhatsApp", use OFIERE_NOTIFY_OPS action:"send_report". The report is generated from live PM data and sent through YOUR connected channels ONLY — not other agents' channels.
+- To set up recurring reports (e.g. "send me a daily report at 9am"), use OFIERE_NOTIFY_OPS action:"schedule_report" with scope_type and recurrence_type.
+- If a report is too long for the channel's message limit, save the full report as a markdown file using OFIERE_FILE_OPS action:"create_text_file" and send a summary to the channel instead.
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -2144,24 +2144,51 @@ function registerNotifyOps(
   supabase: SupabaseClient,
   userId: string,
 ): void {
+  // Helper: resolve the agent's own ID for agent-scoped operations
+  const resolveAgentId = (): string => {
+    try {
+      const state = api.getState?.() || {};
+      return state.agentId || process.env.OFIERE_AGENT_ID || "";
+    } catch { return process.env.OFIERE_AGENT_ID || ""; }
+  };
+
   api.registerTool({
     name: "OFIERE_NOTIFY_OPS",
-    label: "Ofiere Notification Operations",
+    label: "Ofiere Notification & Report Operations",
     description:
-      `Read and manage notifications.\n\n` +
+      `Read/manage notifications and send PM reports to your connected channels.\n\n` +
       `Actions:\n` +
       `- "list": List notifications. Optional: unread_only (true/false), limit\n` +
       `- "mark_read": Mark one as read. Required: id\n` +
       `- "mark_all_read": Mark all as read\n` +
-      `- "delete": Delete a notification. Required: id`,
+      `- "delete": Delete a notification. Required: id\n` +
+      `- "send_report": Send a PM progress report to YOUR connected channels (Telegram, Discord, etc.)\n` +
+      `    Required: scope_type (space|folder|project|task|all)\n` +
+      `    Optional: scope_id, channel_types[] (filter specific channels), include_completed (default true)\n` +
+      `- "schedule_report": Create a recurring/scheduled report\n` +
+      `    Required: scope_type, recurrence_type (hourly|daily|weekly|monthly)\n` +
+      `    Optional: scope_id, scope_label, channel_types[], recurrence_time (HH:MM UTC, default 09:00),\n` +
+      `             recurrence_interval (default 1), recurrence_days_of_week (e.g. "mon,wed,fri"), include_completed\n` +
+      `- "list_schedules": List your active report schedules\n` +
+      `- "delete_schedule": Delete a scheduled report. Required: schedule_id`,
     parameters: {
       type: "object",
       required: ["action"],
       properties: {
-        action: { type: "string", enum: ["list", "mark_read", "mark_all_read", "delete"] },
+        action: { type: "string", enum: ["list", "mark_read", "mark_all_read", "delete", "send_report", "schedule_report", "list_schedules", "delete_schedule"] },
         id: { type: "string", description: "Notification ID" },
+        schedule_id: { type: "string", description: "Schedule ID (for delete_schedule)" },
         unread_only: { type: "boolean", description: "Only show unread" },
         limit: { type: "number", description: "Max results (default 50)" },
+        scope_type: { type: "string", enum: ["space", "folder", "project", "task", "all"], description: "Report scope" },
+        scope_id: { type: "string", description: "ID of the space/folder/project/task" },
+        scope_label: { type: "string", description: "Human-readable label for the scope" },
+        channel_types: { type: "array", items: { type: "string" }, description: "Filter to specific channels (e.g. ['telegram'])" },
+        include_completed: { type: "boolean", description: "Include completed tasks in report" },
+        recurrence_type: { type: "string", enum: ["hourly", "daily", "weekly", "monthly"], description: "How often to send" },
+        recurrence_interval: { type: "number", description: "Interval multiplier (default 1)" },
+        recurrence_time: { type: "string", description: "Time in HH:MM UTC (default 09:00)" },
+        recurrence_days_of_week: { type: "string", description: "Comma-separated days for weekly (e.g. mon,wed,fri)" },
       },
     },
     async execute(_id: string, params: Record<string, unknown>) {
@@ -2194,13 +2221,267 @@ function registerNotifyOps(
           if (error) return err(error.message);
           return ok({ message: "Notification deleted", ok: true });
         }
+
+        // ── SEND REPORT — Dispatch PM report to agent's channels ──
+        case "send_report": {
+          const scopeType = (params.scope_type as string) || "all";
+          const scopeId = params.scope_id as string | undefined;
+          const channelTypes = (params.channel_types as string[]) || [];
+          const includeCompleted = params.include_completed !== false;
+          const agentId = resolveAgentId();
+          if (!agentId) return err("Cannot resolve your agent ID. Ensure OFIERE_AGENT_ID is configured.");
+
+          // Call the dashboard API to generate + dispatch
+          const supabaseUrl = (supabase as any).supabaseUrl || process.env.OFIERE_SUPABASE_URL || process.env.SUPABASE_URL || "";
+          const serviceRoleKey = (supabase as any).supabaseKey || process.env.OFIERE_SERVICE_ROLE_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY || "";
+
+          // Generate report directly from DB (we have service-role access)
+          const reportResult = await generatePMReportDirect(supabase, userId, scopeType, scopeId, agentId, includeCompleted);
+
+          // Dispatch to channels
+          const delivery = await dispatchReportDirect(supabase, userId, agentId, reportResult.report, channelTypes);
+
+          // Create audit notification
+          await supabase.from("notifications").insert({
+            id: crypto.randomUUID(),
+            user_id: userId,
+            title: `Report sent: ${reportResult.scopeLabel}`,
+            message: `Dispatched via ${delivery.sent.join(", ") || "no channels"}. ${reportResult.taskCount} tasks.`,
+            type: "system",
+            category: "project_management",
+            read: false,
+          });
+
+          return ok({
+            message: `Report sent to ${delivery.sent.length} channel(s)`,
+            channels_sent: delivery.sent,
+            channels_failed: delivery.failed,
+            task_count: reportResult.taskCount,
+            scope: reportResult.scopeLabel,
+            report_preview: reportResult.report.slice(0, 500),
+          });
+        }
+
+        // ── SCHEDULE REPORT — Create recurring report ──
+        case "schedule_report": {
+          const scopeType = (params.scope_type as string) || "all";
+          const recurrenceType = (params.recurrence_type as string) || "daily";
+          const agentId = resolveAgentId();
+          if (!agentId) return err("Cannot resolve your agent ID.");
+
+          const recurrenceTime = (params.recurrence_time as string) || "09:00";
+          const recurrenceInterval = (params.recurrence_interval as number) || 1;
+          const recurrenceDaysOfWeek = (params.recurrence_days_of_week as string) || null;
+
+          // Compute next run
+          const [hours, minutes] = recurrenceTime.split(":").map(Number);
+          const next = new Date();
+          next.setUTCHours(hours, minutes, 0, 0);
+          if (next.getTime() <= Date.now()) next.setUTCDate(next.getUTCDate() + 1);
+
+          const { data, error } = await supabase.from("pm_report_schedules").insert({
+            user_id: userId,
+            agent_id: agentId,
+            scope_type: scopeType,
+            scope_id: (params.scope_id as string) || null,
+            scope_label: (params.scope_label as string) || null,
+            channel_types: (params.channel_types as string[]) || [],
+            recurrence_type: recurrenceType,
+            recurrence_interval: recurrenceInterval,
+            recurrence_time: recurrenceTime,
+            recurrence_days_of_week: recurrenceDaysOfWeek,
+            include_completed: params.include_completed !== false,
+            next_run_at: next.toISOString(),
+          }).select().single();
+
+          if (error) return err(error.message);
+          return ok({
+            message: `Scheduled ${recurrenceType} report created`,
+            schedule_id: data.id,
+            next_run: next.toISOString(),
+            recurrence: `${recurrenceType} at ${recurrenceTime} UTC`,
+          });
+        }
+
+        // ── LIST SCHEDULES ──
+        case "list_schedules": {
+          const { data, error } = await supabase.from("pm_report_schedules")
+            .select("*")
+            .eq("user_id", userId)
+            .order("created_at", { ascending: false });
+          if (error) return err(error.message);
+          return ok({ schedules: data || [], count: (data || []).length });
+        }
+
+        // ── DELETE SCHEDULE ──
+        case "delete_schedule": {
+          const scheduleId = (params.schedule_id || params.id) as string;
+          if (!scheduleId) return err("Missing required: schedule_id");
+          const { error } = await supabase.from("pm_report_schedules")
+            .delete().eq("id", scheduleId).eq("user_id", userId);
+          if (error) return err(error.message);
+          return ok({ message: "Schedule deleted", ok: true });
+        }
+
         default:
-          return err(`Unknown action "${action}".`);
+          return err(`Unknown action "${action}". Valid: list, mark_read, mark_all_read, delete, send_report, schedule_report, list_schedules, delete_schedule`);
       }
     },
   });
 }
 
+// ── Inline report generation for plugin (avoids HTTP roundtrip) ──
+
+async function generatePMReportDirect(
+  supabase: SupabaseClient,
+  userId: string,
+  scopeType: string,
+  scopeId: string | undefined,
+  agentId: string,
+  includeCompleted: boolean,
+): Promise<{ report: string; scopeLabel: string; taskCount: number }> {
+  let scopeLabel = "All Projects";
+  let query = supabase.from("tasks").select("id, title, status, priority, progress, completed_at, due_date")
+    .eq("user_id", userId).is("parent_task_id", null);
+
+  if (scopeType === "space" && scopeId) {
+    query = query.eq("space_id", scopeId);
+    const { data: s } = await supabase.from("pm_spaces").select("name").eq("id", scopeId).single();
+    scopeLabel = s?.name || "Space";
+  } else if (scopeType === "folder" && scopeId) {
+    query = query.eq("folder_id", scopeId);
+    const { data: f } = await supabase.from("pm_folders").select("name").eq("id", scopeId).single();
+    scopeLabel = f?.name || "Folder";
+  } else if (scopeType === "project" && scopeId) {
+    query = query.eq("project_id", scopeId);
+    const { data: p } = await supabase.from("pm_folders").select("name").eq("id", scopeId).single();
+    scopeLabel = p?.name || "Project";
+  }
+
+  const { data: tasks } = await query.order("priority", { ascending: false }).limit(40);
+  const all = tasks || [];
+
+  // Agent name
+  let agentName = agentId;
+  const { data: agentRow } = await supabase.from("agents").select("name, codename")
+    .eq("user_id", userId)
+    .or(`id.eq.${agentId},name.ilike.${agentId},codename.ilike.${agentId}`)
+    .limit(1).single();
+  if (agentRow) agentName = agentRow.name || agentRow.codename || agentId;
+
+  const completed = all.filter((t: any) => t.status === "DONE");
+  const inProgress = all.filter((t: any) => t.status === "IN_PROGRESS" || t.status === "RUNNING");
+  const pending = all.filter((t: any) => t.status === "PENDING" || t.status === "NEW");
+  const failed = all.filter((t: any) => t.status === "FAILED");
+
+  const lines: string[] = [];
+  lines.push(`📊 Project Report — ${scopeLabel}`);
+  lines.push(`Agent: ${agentName}`);
+  lines.push("");
+  lines.push("━━━ Summary ━━━");
+  lines.push(`✅ ${completed.length}  |  🔄 ${inProgress.length}  |  ⏳ ${pending.length}  |  ❌ ${failed.length}`);
+
+  if (inProgress.length > 0) {
+    lines.push("");
+    lines.push("━━━ Active ━━━");
+    for (const t of inProgress.slice(0, 8)) {
+      const pl = t.priority === 3 ? "CRIT" : t.priority === 2 ? "HIGH" : t.priority === 1 ? "MED" : "LOW";
+      lines.push(`🔄 [${pl}] ${t.title}${t.progress ? ` — ${t.progress}%` : ""}`);
+    }
+    if (inProgress.length > 8) lines.push(`... +${inProgress.length - 8} more`);
+  }
+
+  if (pending.length > 0) {
+    lines.push("");
+    lines.push("━━━ Pending ━━━");
+    for (const t of pending.slice(0, 6)) {
+      const pl = t.priority === 3 ? "CRIT" : t.priority === 2 ? "HIGH" : t.priority === 1 ? "MED" : "LOW";
+      lines.push(`⏳ [${pl}] ${t.title}`);
+    }
+    if (pending.length > 6) lines.push(`... +${pending.length - 6} more`);
+  }
+
+  if (includeCompleted && completed.length > 0) {
+    lines.push("");
+    lines.push("━━━ Done ━━━");
+    const recent = completed.filter((t: any) => t.completed_at)
+      .sort((a: any, b: any) => new Date(b.completed_at).getTime() - new Date(a.completed_at).getTime())
+      .slice(0, 5);
+    for (const t of recent) {
+      const diff = Date.now() - new Date(t.completed_at).getTime();
+      const mins = Math.floor(diff / 60000);
+      const ago = mins < 60 ? `${mins}m ago` : mins < 1440 ? `${Math.floor(mins / 60)}h ago` : `${Math.floor(mins / 1440)}d ago`;
+      lines.push(`✅ ${t.title} (${ago})`);
+    }
+  }
+
+  const now = new Date();
+  lines.push("");
+  lines.push(`Generated: ${now.toISOString().replace("T", " ").slice(0, 16)} UTC`);
+
+  return { report: lines.join("\n"), scopeLabel, taskCount: all.length };
+}
+
+async function dispatchReportDirect(
+  supabase: SupabaseClient,
+  userId: string,
+  agentId: string,
+  report: string,
+  channelTypes: string[],
+): Promise<{ sent: string[]; failed: string[] }> {
+  // Query agent's active channel bindings
+  let query = supabase.from("channel_bindings").select("channel_type, channel_account_id, channel_config")
+    .eq("user_id", userId)
+    .eq("agent_id", agentId)
+    .eq("notifications_enabled", true)
+    .eq("is_active", true);
+
+  if (channelTypes.length > 0) {
+    query = query.in("channel_type", channelTypes);
+  }
+
+  const { data: bindings } = await query;
+  if (!bindings || bindings.length === 0) {
+    return { sent: [], failed: ["No active channel bindings found for this agent"] };
+  }
+
+  const LIMITS: Record<string, number> = { telegram: 4096, discord: 2000, slack: 40000, whatsapp: 65536 };
+  const sent: string[] = [];
+  const failed: string[] = [];
+
+  for (const b of bindings) {
+    const limit = LIMITS[b.channel_type] || 4000;
+    let msg = report;
+    if (msg.length > limit) {
+      msg = msg.substring(0, limit - 80) + "\n\n... [Full report on dashboard]";
+    }
+
+    // Use the Ofiere dashboard API to send via gateway
+    // The dashboard URL is derived from the Supabase URL
+    const dashboardUrl = process.env.OFIERE_DASHBOARD_URL || "https://ofiere.com";
+    const dispatchSecret = process.env.DISPATCH_SECRET || "";
+
+    try {
+      const res = await fetch(`${dashboardUrl}/api/channels/gateway-send`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "x-dispatch-secret": dispatchSecret },
+        body: JSON.stringify({
+          userId,
+          channelType: b.channel_type,
+          accountId: b.channel_account_id || null,
+          message: msg,
+        }),
+      });
+      if (res.ok) sent.push(b.channel_type);
+      else failed.push(`${b.channel_type}: HTTP ${res.status}`);
+    } catch (e: any) {
+      failed.push(`${b.channel_type}: ${e.message || "fetch error"}`);
+    }
+  }
+
+  return { sent, failed };
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // META-TOOL 8: OFIERE_MEMORY_OPS — Conversations & Knowledge Fragments
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -3234,19 +3515,62 @@ function registerFileOps(
 
 // ── File Ops helpers ─────────────────────────────────────────────────────────
 
+/** MIME types allowed by the space-files storage bucket. */
+const ALLOWED_STORAGE_MIMES = new Set([
+  "image/png", "image/jpeg", "image/gif", "image/webp", "image/svg+xml",
+  "video/mp4", "video/webm", "video/quicktime",
+  "audio/mpeg", "audio/wav", "audio/ogg",
+  "application/pdf", "text/plain", "text/markdown", "text/csv",
+  "text/html", "text/css", "application/json",
+  "application/javascript", "text/javascript", "application/typescript",
+  "application/zip", "application/x-tar", "application/gzip",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "application/octet-stream",
+]);
+
+/**
+ * Simple FNV-1a 32-bit hash → 8-char hex string.
+ * Used to generate stable, short slugs from non-ASCII filenames.
+ */
+function fnv1aHash(str: string): string {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = (hash * 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
 /**
  * Sanitize a filename for safe use as a Supabase storage object key.
- * Strips characters that break storage APIs (parens, em-dashes, exclamation marks, etc.)
- * while preserving extension and readability. The original filename is kept in DB metadata.
+ * Strips characters that break storage APIs while preserving extension and readability.
+ * For Unicode-heavy filenames, generates a hash-based slug to maintain uniqueness.
+ * The original filename is always kept in DB metadata.
  */
 function sanitizeStorageFileName(fileName: string): string {
-  // Replace spaces with hyphens, strip anything not alphanumeric, hyphen, underscore, or dot
-  return fileName
+  // Split extension from stem
+  const dotIdx = fileName.lastIndexOf(".");
+  const stem = dotIdx > 0 ? fileName.slice(0, dotIdx) : fileName;
+  const ext = dotIdx > 0 ? fileName.slice(dotIdx) : ""; // includes dot
+
+  // Sanitize stem: spaces → hyphens, strip non-ASCII/non-safe chars
+  let safeStem = stem
     .replace(/\s+/g, "-")
-    .replace(/[^a-zA-Z0-9._-]/g, "")
-    .replace(/-{2,}/g, "-")     // collapse multiple hyphens
-    .replace(/^-+|-+$/g, "")    // trim leading/trailing hyphens
-    || "file";                   // fallback if everything was stripped
+    .replace(/[^a-zA-Z0-9_-]/g, "")
+    .replace(/-{2,}/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  // If stem collapsed (e.g. all Unicode), generate hash-based slug for traceability
+  if (safeStem.length < 3) {
+    safeStem = `f-${fnv1aHash(stem)}`;
+  }
+
+  // Sanitize extension too (should be safe but belt-and-suspenders)
+  const safeExt = ext.replace(/[^a-zA-Z0-9.]/g, "");
+
+  return `${safeStem}${safeExt}` || "file";
 }
 
 // ── File Ops handlers ────────────────────────────────────────────────────────
@@ -3408,6 +3732,7 @@ async function handleUploadFile(
 
     // Auto-detect MIME from extension if not explicitly provided
     let mimeType = params.file_type as string;
+    let mimeWarning: string | undefined;
     if (!mimeType) {
       const ext = fileName.split(".").pop()?.toLowerCase() || "";
       const binaryMimeMap: Record<string, string> = {
@@ -3428,6 +3753,10 @@ async function handleUploadFile(
         yml: "text/yaml", xml: "text/xml",
       };
       mimeType = binaryMimeMap[ext] || "application/octet-stream";
+    } else if (!ALLOWED_STORAGE_MIMES.has(mimeType)) {
+      // Explicit MIME not in bucket allowlist → fall back to octet-stream to prevent upload rejection
+      mimeWarning = `Requested MIME "${mimeType}" is not in storage allowlist — stored as application/octet-stream. The original type is preserved in file metadata.`;
+      mimeType = "application/octet-stream";
     }
 
     const safeFileName = sanitizeStorageFileName(fileName);
@@ -3439,6 +3768,10 @@ async function handleUploadFile(
 
     if (uploadErr) return err(`Storage upload failed: ${uploadErr.message}`);
 
+    // Store the originally-requested MIME type in DB (for downstream consumers),
+    // but use the storage-safe MIME for the actual upload
+    const dbMimeType = (params.file_type as string) || mimeType;
+
     const { data, error } = await supabase
       .from("pm_space_files")
       .insert({
@@ -3446,7 +3779,7 @@ async function handleUploadFile(
         space_id: spaceId,
         folder_id: (params.folder_id as string) || null,
         file_name: fileName,
-        file_type: mimeType,
+        file_type: dbMimeType,
         file_size: bytes.length,
         storage_path: storagePath,
         is_shared: false,
@@ -3456,7 +3789,12 @@ async function handleUploadFile(
       .single();
 
     if (error) return err(error.message);
-    return ok({ message: `File "${fileName}" uploaded (${bytes.length} bytes)`, file: data });
+    const result: Record<string, unknown> = {
+      message: `File "${fileName}" uploaded (${bytes.length} bytes)`,
+      file: data,
+    };
+    if (mimeWarning) result.warning = mimeWarning;
+    return ok(result);
   } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
 }