ofiere-openclaw-plugin 4.12.2 → 4.13.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ofiere-openclaw-plugin",
-  "version": "4.12.2",
+  "version": "4.13.0",
   "type": "module",
-  "description": "OpenClaw plugin for Ofiere PM - 10 meta-tools with 13-action workflow mastery covering tasks, agents, projects, scheduling, knowledge, workflows, notifications, memory, prompts, and constellation agent architecture",
+  "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"],
   "homepage": "https://github.com/gilanggemar/Ofiere",
   "repository": {

package/src/prompt.ts

@@ -93,6 +93,20 @@ const TOOL_DOCS: Record<string, string> = {
     - list_agent_mesh: See the sovereignty map (which agent owns what domain)
     - New agents get workspace-<name>/ with IDENTITY.md, SOUL.md, AGENTS.md, TOOLS.md, <CODENAME>.md, and skills/
     - All changes sync to the Constellation dashboard automatically`,
+
+  OFIERE_FILE_OPS: `- **OFIERE_FILE_OPS** — Manage Space Files (action: "list_files", "list_folders", "create_folder", "create_text_file", "upload_file", "read_text_file", "rename_file", "rename_folder", "move_file", "move_folder", "delete_file", "delete_folder", "share_file", "unshare_file")
+    - list_files: Files in a space. Required: space_id. Optional: folder_id, shared_only
+    - list_folders: Folders in a space. Required: space_id. Optional: parent_folder_id
+    - create_folder: New folder. Required: space_id, name. Optional: parent_folder_id
+    - create_text_file: Create text file (md, txt, json, csv, etc.). Required: space_id, file_name, content. Optional: folder_id
+    - upload_file: Upload binary (base64). Required: space_id, file_name, content_base64. Optional: folder_id, file_type
+    - read_text_file: Read file content. Required: file_id. Use when task instructions reference a file with @[name](file:ID)
+    - rename_file / rename_folder: Rename. Required: file_id/folder_id + new_name
+    - move_file / move_folder: Move to target folder (null=root). Required: file_id/folder_id
+    - delete_file: Remove file + storage. Required: file_id
+    - delete_folder: Remove folder + all nested files recursively. Required: folder_id
+    - share_file / unshare_file: Toggle shared status. Required: file_id
+    - Files created here appear in the PM Space Files tab immediately`,
 };
 
 export function getSystemPrompt(state: {
@@ -148,6 +162,9 @@ ${toolDocs}
 - Use add_approval when a task needs sign-off from a human or another agent before proceeding. Approvers can be agents (by name) or humans.
 - Task approvals (OFIERE_TASK_OPS) are SEPARATE from workflow gate approvals (human_approval nodes). Do not confuse them.
 - When an agent completes critical work, consider adding an approval request for human review before marking the task DONE.
+- 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.
 </ofiere-pm>`;
   }
 

package/src/tools.ts

@@ -293,8 +293,8 @@ function registerTaskOps(
         approval_id: { type: "string", description: "Approval ID for resolve_approval action" },
         approval_status: {
           type: "string",
-          description: "Approval decision: approved or rejected. Used with resolve_approval.",
-          enum: ["approved", "rejected"],
+          description: "Approval status filter (pending|approved|rejected) for list_approvals, or decision (approved|rejected) for resolve_approval.",
+          enum: ["pending", "approved", "rejected"],
         },
         comment: { type: "string", description: "Comment for approval (add_approval or resolve_approval)" },
       },
@@ -3132,6 +3132,526 @@ function registerConstellationOps(
   });
 }
 
+// ═══════════════════════════════════════════════════════════════════════════════
+// META-TOOL 11: OFIERE_FILE_OPS — Space File Management
+// ═══════════════════════════════════════════════════════════════════════════════
+
+function registerFileOps(
+  api: any,
+  supabase: SupabaseClient,
+  userId: string,
+): void {
+  api.registerTool({
+    name: "OFIERE_FILE_OPS",
+    label: "Ofiere File Operations",
+    description:
+      `Manage files and folders in the Ofiere PM Space Files explorer.\n\n` +
+      `Actions:\n` +
+      `- "list_files": List files. Required: space_id. Optional: folder_id, shared_only\n` +
+      `- "list_folders": List folders. Required: space_id. Optional: parent_folder_id\n` +
+      `- "create_folder": Create a folder. Required: space_id, name. Optional: parent_folder_id\n` +
+      `- "create_text_file": Create a text file (md, txt, json, etc.). Required: space_id, file_name, content. Optional: folder_id\n` +
+      `- "upload_file": Upload a binary file (base64-encoded). Required: space_id, file_name, content_base64. Optional: folder_id, file_type\n` +
+      `- "read_text_file": Read the text content of a file. Required: file_id\n` +
+      `- "rename_file": Rename a file. Required: file_id, new_name\n` +
+      `- "rename_folder": Rename a folder. Required: folder_id, new_name\n` +
+      `- "move_file": Move file to a folder (null=root). Required: file_id. Optional: target_folder_id\n` +
+      `- "move_folder": Move folder. Required: folder_id. Optional: target_parent_id\n` +
+      `- "delete_file": Delete file + storage blob. Required: file_id\n` +
+      `- "delete_folder": Delete folder + all contents recursively. Required: folder_id\n` +
+      `- "share_file": Mark file as shared (visible cross-space). Required: file_id\n` +
+      `- "unshare_file": Remove shared status. Required: file_id\n\n` +
+      `When task instructions contain @[filename](file:FILE_ID), use read_text_file to retrieve the content.`,
+    parameters: {
+      type: "object",
+      required: ["action"],
+      properties: {
+        action: {
+          type: "string",
+          description: "The operation to perform",
+          enum: [
+            "list_files", "list_folders", "create_folder",
+            "create_text_file", "upload_file", "read_text_file",
+            "rename_file", "rename_folder",
+            "move_file", "move_folder",
+            "delete_file", "delete_folder",
+            "share_file", "unshare_file",
+          ],
+        },
+        space_id: { type: "string", description: "PM Space ID" },
+        folder_id: { type: "string", description: "Folder ID for scoping or placement" },
+        parent_folder_id: { type: "string", description: "Parent folder ID for nesting" },
+        target_folder_id: { type: "string", description: "Target folder to move file into (null=root)" },
+        target_parent_id: { type: "string", description: "Target parent folder to move folder into (null=root)" },
+        file_id: { type: "string", description: "File ID for operations on existing files" },
+        name: { type: "string", description: "Folder name (for create_folder)" },
+        file_name: { type: "string", description: "File name including extension (e.g. 'report.md')" },
+        new_name: { type: "string", description: "New name for rename operations" },
+        content: { type: "string", description: "Text content for create_text_file" },
+        content_base64: { type: "string", description: "Base64-encoded binary content for upload_file" },
+        file_type: { type: "string", description: "MIME type (auto-detected if omitted)" },
+        shared_only: { type: "boolean", description: "If true, only return shared files" },
+      },
+    },
+    async execute(_id: string, params: Record<string, unknown>) {
+      const action = params.action as string;
+
+      switch (action) {
+        case "list_files":
+          return handleListFiles(supabase, userId, params);
+        case "list_folders":
+          return handleListFolders(supabase, userId, params);
+        case "create_folder":
+          return handleCreateSpaceFolder(supabase, userId, params);
+        case "create_text_file":
+          return handleCreateTextFile(supabase, userId, params);
+        case "upload_file":
+          return handleUploadFile(supabase, userId, params);
+        case "read_text_file":
+          return handleReadTextFile(supabase, userId, params);
+        case "rename_file":
+          return handleRenameFile(supabase, userId, params);
+        case "rename_folder":
+          return handleRenameSpaceFolder(supabase, userId, params);
+        case "move_file":
+          return handleMoveFile(supabase, userId, params);
+        case "move_folder":
+          return handleMoveSpaceFolder(supabase, userId, params);
+        case "delete_file":
+          return handleDeleteSpaceFile(supabase, userId, params);
+        case "delete_folder":
+          return handleDeleteSpaceFolder(supabase, userId, params);
+        case "share_file":
+          return handleShareFile(supabase, userId, params, true);
+        case "unshare_file":
+          return handleShareFile(supabase, userId, params, false);
+        default:
+          return err(`Unknown action "${action}". Valid: list_files, list_folders, create_folder, create_text_file, upload_file, read_text_file, rename_file, rename_folder, move_file, move_folder, delete_file, delete_folder, share_file, unshare_file`);
+      }
+    },
+  });
+}
+
+// ── File Ops handlers ────────────────────────────────────────────────────────
+
+async function handleListFiles(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const spaceId = params.space_id as string;
+    if (!spaceId) return err("Missing required field: space_id");
+
+    let query = supabase
+      .from("pm_space_files")
+      .select("id, file_name, file_type, file_size, folder_id, is_shared, source, created_at")
+      .eq("user_id", userId)
+      .eq("space_id", spaceId)
+      .order("created_at", { ascending: false });
+
+    if (params.shared_only) query = query.eq("is_shared", true);
+    if (params.folder_id !== undefined) {
+      if (params.folder_id === null || params.folder_id === "root") {
+        query = query.is("folder_id", null);
+      } else {
+        query = query.eq("folder_id", params.folder_id as string);
+      }
+    }
+
+    const { data, error } = await query;
+    if (error) return err(error.message);
+    return ok({ files: data || [], count: (data || []).length });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleListFolders(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const spaceId = params.space_id as string;
+    if (!spaceId) return err("Missing required field: space_id");
+
+    let query = supabase
+      .from("pm_space_folders")
+      .select("id, name, parent_folder_id, is_shared, created_at")
+      .eq("user_id", userId)
+      .eq("space_id", spaceId)
+      .order("name", { ascending: true });
+
+    if (params.parent_folder_id !== undefined) {
+      if (params.parent_folder_id === null || params.parent_folder_id === "root") {
+        query = query.is("parent_folder_id", null);
+      } else {
+        query = query.eq("parent_folder_id", params.parent_folder_id as string);
+      }
+    }
+
+    const { data, error } = await query;
+    if (error) return err(error.message);
+    return ok({ folders: data || [], count: (data || []).length });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleCreateSpaceFolder(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const spaceId = params.space_id as string;
+    const name = params.name as string;
+    if (!spaceId) return err("Missing required field: space_id");
+    if (!name) return err("Missing required field: name");
+
+    const { data, error } = await supabase
+      .from("pm_space_folders")
+      .insert({
+        user_id: userId,
+        space_id: spaceId,
+        name,
+        parent_folder_id: (params.parent_folder_id as string) || null,
+        is_shared: false,
+      })
+      .select()
+      .single();
+
+    if (error) return err(error.message);
+    return ok({ message: `Folder "${name}" created`, folder: data });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleCreateTextFile(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const spaceId = params.space_id as string;
+    const fileName = params.file_name as string;
+    const content = params.content as string;
+    if (!spaceId) return err("Missing required field: space_id");
+    if (!fileName) return err("Missing required field: file_name");
+    if (content === undefined || content === null) return err("Missing required field: content");
+
+    // Detect MIME type from extension
+    const ext = fileName.split(".").pop()?.toLowerCase() || "";
+    const mimeMap: Record<string, string> = {
+      md: "text/markdown", txt: "text/plain", json: "application/json",
+      csv: "text/csv", html: "text/html", css: "text/css",
+      js: "text/javascript", ts: "text/typescript", yaml: "text/yaml",
+      yml: "text/yaml", xml: "text/xml", svg: "image/svg+xml",
+      sh: "text/x-shellscript", py: "text/x-python", toml: "text/toml",
+    };
+    const mimeType = mimeMap[ext] || "text/plain";
+
+    // Upload to storage
+    const storagePath = `${userId}/${spaceId}/${Date.now()}-${fileName}`;
+    const blob = new Blob([content], { type: mimeType });
+    const buffer = await blob.arrayBuffer();
+
+    const { error: uploadErr } = await supabase.storage
+      .from("space-files")
+      .upload(storagePath, buffer, { contentType: mimeType, upsert: false });
+
+    if (uploadErr) return err(`Storage upload failed: ${uploadErr.message}`);
+
+    // Insert metadata
+    const { data, error } = await supabase
+      .from("pm_space_files")
+      .insert({
+        user_id: userId,
+        space_id: spaceId,
+        folder_id: (params.folder_id as string) || null,
+        file_name: fileName,
+        file_type: mimeType,
+        file_size: content.length,
+        storage_path: storagePath,
+        is_shared: false,
+        source: "agent",
+      })
+      .select()
+      .single();
+
+    if (error) return err(error.message);
+    return ok({ message: `File "${fileName}" created (${content.length} bytes)`, file: data });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleUploadFile(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const spaceId = params.space_id as string;
+    const fileName = params.file_name as string;
+    const b64 = params.content_base64 as string;
+    if (!spaceId) return err("Missing required field: space_id");
+    if (!fileName) return err("Missing required field: file_name");
+    if (!b64) return err("Missing required field: content_base64");
+
+    // Decode base64
+    const binaryStr = atob(b64);
+    const bytes = new Uint8Array(binaryStr.length);
+    for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
+
+    const mimeType = (params.file_type as string) || "application/octet-stream";
+    const storagePath = `${userId}/${spaceId}/${Date.now()}-${fileName}`;
+
+    const { error: uploadErr } = await supabase.storage
+      .from("space-files")
+      .upload(storagePath, bytes.buffer, { contentType: mimeType, upsert: false });
+
+    if (uploadErr) return err(`Storage upload failed: ${uploadErr.message}`);
+
+    const { data, error } = await supabase
+      .from("pm_space_files")
+      .insert({
+        user_id: userId,
+        space_id: spaceId,
+        folder_id: (params.folder_id as string) || null,
+        file_name: fileName,
+        file_type: mimeType,
+        file_size: bytes.length,
+        storage_path: storagePath,
+        is_shared: false,
+        source: "agent",
+      })
+      .select()
+      .single();
+
+    if (error) return err(error.message);
+    return ok({ message: `File "${fileName}" uploaded (${bytes.length} bytes)`, file: data });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleReadTextFile(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const fileId = params.file_id as string;
+    if (!fileId) return err("Missing required field: file_id");
+
+    // Get metadata
+    const { data: fileMeta, error: metaErr } = await supabase
+      .from("pm_space_files")
+      .select("storage_path, file_name, file_type, file_size")
+      .eq("id", fileId)
+      .eq("user_id", userId)
+      .single();
+
+    if (metaErr || !fileMeta) return err(`File not found: ${fileId}`);
+
+    // Download from storage
+    const { data: blob, error: dlErr } = await supabase.storage
+      .from("space-files")
+      .download(fileMeta.storage_path);
+
+    if (dlErr || !blob) return err(`Download failed: ${dlErr?.message || "unknown"}`);
+
+    const text = await blob.text();
+
+    return ok({
+      file_id: fileId,
+      file_name: fileMeta.file_name,
+      file_type: fileMeta.file_type,
+      file_size: fileMeta.file_size,
+      content: text,
+    });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleRenameFile(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const fileId = params.file_id as string;
+    const newName = params.new_name as string;
+    if (!fileId) return err("Missing required field: file_id");
+    if (!newName) return err("Missing required field: new_name");
+
+    const { error } = await supabase
+      .from("pm_space_files")
+      .update({ file_name: newName, updated_at: new Date().toISOString() })
+      .eq("id", fileId)
+      .eq("user_id", userId);
+
+    if (error) return err(error.message);
+    return ok({ message: `File renamed to "${newName}"` });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleRenameSpaceFolder(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const folderId = params.folder_id as string;
+    const newName = params.new_name as string;
+    if (!folderId) return err("Missing required field: folder_id");
+    if (!newName) return err("Missing required field: new_name");
+
+    const { error } = await supabase
+      .from("pm_space_folders")
+      .update({ name: newName, updated_at: new Date().toISOString() })
+      .eq("id", folderId)
+      .eq("user_id", userId);
+
+    if (error) return err(error.message);
+    return ok({ message: `Folder renamed to "${newName}"` });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleMoveFile(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const fileId = params.file_id as string;
+    if (!fileId) return err("Missing required field: file_id");
+
+    const targetFolderId = params.target_folder_id !== undefined
+      ? (params.target_folder_id as string | null)
+      : null;
+
+    const { error } = await supabase
+      .from("pm_space_files")
+      .update({ folder_id: targetFolderId, updated_at: new Date().toISOString() })
+      .eq("id", fileId)
+      .eq("user_id", userId);
+
+    if (error) return err(error.message);
+    return ok({ message: `File moved to ${targetFolderId || "root"}` });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleMoveSpaceFolder(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const folderId = params.folder_id as string;
+    if (!folderId) return err("Missing required field: folder_id");
+
+    const targetParentId = params.target_parent_id !== undefined
+      ? (params.target_parent_id as string | null)
+      : null;
+
+    const { error } = await supabase
+      .from("pm_space_folders")
+      .update({ parent_folder_id: targetParentId, updated_at: new Date().toISOString() })
+      .eq("id", folderId)
+      .eq("user_id", userId);
+
+    if (error) return err(error.message);
+    return ok({ message: `Folder moved to ${targetParentId || "root"}` });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleDeleteSpaceFile(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const fileId = params.file_id as string;
+    if (!fileId) return err("Missing required field: file_id");
+
+    // Get storage path first
+    const { data: fileMeta } = await supabase
+      .from("pm_space_files")
+      .select("storage_path, file_name")
+      .eq("id", fileId)
+      .eq("user_id", userId)
+      .single();
+
+    if (!fileMeta) return err(`File not found: ${fileId}`);
+
+    // Delete from storage
+    if (fileMeta.storage_path) {
+      await supabase.storage.from("space-files").remove([fileMeta.storage_path]);
+    }
+
+    // Delete metadata
+    const { error } = await supabase
+      .from("pm_space_files")
+      .delete()
+      .eq("id", fileId)
+      .eq("user_id", userId);
+
+    if (error) return err(error.message);
+    return ok({ message: `File "${fileMeta.file_name}" deleted`, deleted: true });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleDeleteSpaceFolder(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+): Promise<ToolResult> {
+  try {
+    const folderId = params.folder_id as string;
+    if (!folderId) return err("Missing required field: folder_id");
+
+    // Recursively collect all child folder IDs
+    const allFolderIds: string[] = [folderId];
+    const queue = [folderId];
+    while (queue.length > 0) {
+      const parentId = queue.shift()!;
+      const { data: children } = await supabase
+        .from("pm_space_folders")
+        .select("id")
+        .eq("parent_folder_id", parentId)
+        .eq("user_id", userId);
+      if (children) {
+        for (const child of children) {
+          allFolderIds.push(child.id);
+          queue.push(child.id);
+        }
+      }
+    }
+
+    // Delete all files in these folders (storage + metadata)
+    const { data: files } = await supabase
+      .from("pm_space_files")
+      .select("id, storage_path")
+      .in("folder_id", allFolderIds)
+      .eq("user_id", userId);
+
+    if (files && files.length > 0) {
+      const storagePaths = files.map((f: any) => f.storage_path).filter(Boolean);
+      if (storagePaths.length > 0) {
+        await supabase.storage.from("space-files").remove(storagePaths);
+      }
+      await supabase
+        .from("pm_space_files")
+        .delete()
+        .in("id", files.map((f: any) => f.id))
+        .eq("user_id", userId);
+    }
+
+    // Delete all folders (deepest first)
+    for (const id of allFolderIds.reverse()) {
+      await supabase
+        .from("pm_space_folders")
+        .delete()
+        .eq("id", id)
+        .eq("user_id", userId);
+    }
+
+    return ok({
+      message: `Folder and all contents deleted`,
+      folders_deleted: allFolderIds.length,
+      files_deleted: files?.length || 0,
+    });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
+async function handleShareFile(
+  supabase: SupabaseClient, userId: string, params: Record<string, unknown>,
+  shared: boolean,
+): Promise<ToolResult> {
+  try {
+    const fileId = params.file_id as string;
+    if (!fileId) return err("Missing required field: file_id");
+
+    const { error } = await supabase
+      .from("pm_space_files")
+      .update({ is_shared: shared, updated_at: new Date().toISOString() })
+      .eq("id", fileId)
+      .eq("user_id", userId);
+
+    if (error) return err(error.message);
+    return ok({ message: `File ${shared ? "shared" : "unshared"}` });
+  } catch (e) { return err(e instanceof Error ? e.message : String(e)); }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════
 // Public: Register All Meta-Tools
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -3159,9 +3679,10 @@ export function registerTools(
   registerMemoryOps(api, supabase, userId);                   // 8
   registerPromptOps(api, supabase, userId);                   // 9
   registerConstellationOps(api, supabase, userId);            // 10
+  registerFileOps(api, supabase, userId);                     // 11
 
   // ── Count and log ──
-  const toolCount = 10;
+  const toolCount = 11;
   const callerName = getCallingAgentName(api);
   const agentLabel = fallbackAgentId || callerName || "auto-detect";
   api.logger.info(`[ofiere] ${toolCount} meta-tools registered (agent: ${agentLabel})`);