openclaw-remote 0.5.5 → 0.5.7

package/dist/index.js

@@ -2781,6 +2781,55 @@ async function getBoardHealth(account) {
     }
   );
 }
+async function getGoals(account, filters) {
+  const params = new URLSearchParams();
+  if (filters?.status) params.set("status", filters.status);
+  if (filters?.parent_id !== void 0) params.set("parent_id", filters.parent_id);
+  if (filters?.assigned_to) params.set("assigned_to", filters.assigned_to);
+  const qs = params.toString();
+  const path = `/api/v1/goals${qs ? `?${qs}` : ""}`;
+  return apiFetch(
+    buildUrl(account, path),
+    {
+      method: "GET",
+      headers: buildHeaders(account)
+    }
+  );
+}
+async function createGoal(account, data) {
+  return apiFetch(
+    buildUrl(account, "/api/v1/goals"),
+    {
+      method: "POST",
+      headers: buildHeaders(account),
+      body: JSON.stringify(data)
+    }
+  );
+}
+async function updateGoal(account, goalId, updates) {
+  return apiFetch(
+    buildUrl(account, `/api/v1/goals/${encodeURIComponent(goalId)}`),
+    {
+      method: "PATCH",
+      headers: buildHeaders(account),
+      body: JSON.stringify(updates)
+    }
+  );
+}
+async function updateRoleBundle(account, roleId, data) {
+  return apiFetch(
+    buildUrl(account, `/api/v1/roles/${encodeURIComponent(roleId)}/bundle`),
+    {
+      method: "PATCH",
+      headers: buildHeaders(account),
+      body: JSON.stringify({
+        bundle_slug: data.bundle_slug,
+        bundle_version: data.bundle_version,
+        status: data.generation_status
+      })
+    }
+  );
+}
 async function getTeam(account) {
   return apiFetch(
     buildUrl(account, "/api/v1/team"),
@@ -3130,6 +3179,9 @@ function createRemotePlugin() {
             ),
             epic_id: Type.Optional(
               Type.String({ description: "Epic ID to group the task under" })
+            ),
+            goal_id: Type.Optional(
+              Type.String({ description: "Goal ID to link the task to" })
             )
           }),
           execute: async (_toolCallId, args) => {
@@ -3140,7 +3192,8 @@ function createRemotePlugin() {
               type: args.type,
               priority: args.priority,
               assigned_role_id: args.assigned_role_id,
-              epic_id: args.epic_id
+              epic_id: args.epic_id,
+              goal_id: args.goal_id
             });
             if (!result.ok) {
               return {
@@ -3187,6 +3240,9 @@ function createRemotePlugin() {
             epic_id: Type.Optional(
               Type.String({ description: "Epic ID to group the task under (or null to remove)" })
             ),
+            goal_id: Type.Optional(
+              Type.String({ description: "Goal ID to link the task to (or null to remove)" })
+            ),
             assigned_role_id: Type.Optional(
               Type.String({ description: "Role ID to assign the task to" })
             )
@@ -3485,6 +3541,177 @@ function createRemotePlugin() {
               details: { ok: true, team, total, humans, agents }
             };
           }
+        },
+        // 9. remote_list_goals
+        {
+          name: "remote_list_goals",
+          label: "List goals on the Remote project board",
+          description: "List goals on the Remote project board. Optionally filter by status (active/achieved/abandoned), parent_id (null for top-level), or assigned_to (me).",
+          parameters: Type.Object({
+            status: optionalStringEnum(["active", "achieved", "abandoned"], {
+              description: "Filter by status: active, achieved, or abandoned"
+            }),
+            parent_id: Type.Optional(
+              Type.String({ description: "Filter by parent goal ID. Use 'null' for top-level goals." })
+            ),
+            assigned_to: Type.Optional(
+              Type.String({ description: "Filter by assignee. Use 'me' for goals owned by your roles." })
+            )
+          }),
+          execute: async (_toolCallId, args) => {
+            const account = resolveToolAccount();
+            const result = await getGoals(account, {
+              status: args.status,
+              parent_id: args.parent_id,
+              assigned_to: args.assigned_to
+            });
+            if (!result.ok) {
+              return {
+                content: [{ type: "text", text: `\u274C Failed to list goals: ${result.error}` }],
+                details: { ok: false, error: result.error }
+              };
+            }
+            const goals = result.data.goals;
+            if (goals.length === 0) {
+              return {
+                content: [{ type: "text", text: `\u{1F3AF} No goals found.` }],
+                details: { ok: true, goals: [] }
+              };
+            }
+            const lines = [`\u{1F3AF} **${goals.length} goal(s):**`, ""];
+            for (const g of goals) {
+              const pct = g.progress ?? 0;
+              const bar = "\u2588".repeat(Math.round(pct / 10)) + "\u2591".repeat(10 - Math.round(pct / 10));
+              const role = g.project_roles?.role_name || "";
+              const date = g.target_date ? ` \u{1F3AF} ${new Date(g.target_date).toLocaleDateString()}` : "";
+              const kids = g.children_count ? ` (${g.children_count} sub-goals)` : "";
+              lines.push(`- **${g.title}** [${g.status}] ${bar} ${pct}%${role ? ` \u2014 ${role}` : ""}${date}${kids} (id: ${g.id})`);
+            }
+            return {
+              content: [{ type: "text", text: lines.join("\n") }],
+              details: { ok: true, goals }
+            };
+          }
+        },
+        // 10. remote_create_goal
+        {
+          name: "remote_create_goal",
+          label: "Create a goal on the Remote project board",
+          description: "Create a new goal on the Remote project board. Specify title, and optionally description, success_criteria, parent_id (for sub-goals), owner_role_id, and target_date.",
+          parameters: Type.Object({
+            title: Type.String({ description: "Goal title" }),
+            description: Type.Optional(Type.String({ description: "Goal description" })),
+            success_criteria: Type.Optional(Type.String({ description: "How to measure achievement" })),
+            parent_id: Type.Optional(Type.String({ description: "Parent goal ID (for sub-goals)" })),
+            owner_role_id: Type.Optional(Type.String({ description: "Role ID that owns this goal" })),
+            target_date: Type.Optional(Type.String({ description: "Target date (ISO format)" }))
+          }),
+          execute: async (_toolCallId, args) => {
+            const account = resolveToolAccount();
+            const result = await createGoal(account, {
+              title: args.title,
+              description: args.description,
+              success_criteria: args.success_criteria,
+              parent_id: args.parent_id,
+              owner_role_id: args.owner_role_id,
+              target_date: args.target_date
+            });
+            if (!result.ok) {
+              return {
+                content: [{ type: "text", text: `\u274C Failed to create goal: ${result.error}` }],
+                details: { ok: false, error: result.error }
+              };
+            }
+            const goal = result.data.goal;
+            const text = [
+              `\u2705 Goal created!`,
+              `- **Title**: ${goal.title}`,
+              `- **ID**: ${goal.id}`,
+              `- **Status**: ${goal.status}`,
+              goal.parent_id ? `- **Parent**: ${goal.parent_id}` : null
+            ].filter(Boolean).join("\n");
+            return {
+              content: [{ type: "text", text }],
+              details: { ok: true, goal }
+            };
+          }
+        },
+        // 11. remote_update_goal
+        {
+          name: "remote_update_goal",
+          label: "Update a goal on the Remote project board",
+          description: "Update an existing goal. Specify goal_id and any fields to change: title, description, status (active/achieved/abandoned), success_criteria, target_date, owner_role_id.",
+          parameters: Type.Object({
+            goal_id: Type.String({ description: "ID of the goal to update" }),
+            title: Type.Optional(Type.String({ description: "New goal title" })),
+            description: Type.Optional(Type.String({ description: "New description" })),
+            status: optionalStringEnum(["active", "achieved", "abandoned"], {
+              description: "New status: active, achieved, or abandoned"
+            }),
+            success_criteria: Type.Optional(Type.String({ description: "New success criteria" })),
+            target_date: Type.Optional(Type.String({ description: "New target date (ISO format)" })),
+            owner_role_id: Type.Optional(Type.String({ description: "New owner role ID" }))
+          }),
+          execute: async (_toolCallId, args) => {
+            const account = resolveToolAccount();
+            const { goal_id, ...updates } = args;
+            const result = await updateGoal(account, goal_id, updates);
+            if (!result.ok) {
+              return {
+                content: [{ type: "text", text: `\u274C Failed to update goal: ${result.error}` }],
+                details: { ok: false, error: result.error }
+              };
+            }
+            const goal = result.data.goal;
+            const text = [
+              `\u2705 Goal updated!`,
+              `- **Title**: ${goal.title}`,
+              `- **Status**: ${goal.status}`,
+              `- **Progress**: ${goal.progress}%`
+            ].join("\n");
+            return {
+              content: [{ type: "text", text }],
+              details: { ok: true, goal }
+            };
+          }
+        },
+        // remote_update_role — update role bundle info (agent callback)
+        {
+          name: "remote_update_role",
+          label: "Update a role's agent bundle info",
+          description: "Update a role's bundle_slug, bundle_version, and generation_status. Used by the agent-builder to report back after generating a bundle.",
+          parameters: Type.Object({
+            role_id: Type.String({ description: "ID of the role to update" }),
+            bundle_slug: Type.Optional(Type.String({ description: "Published bundle slug (e.g. @org/agent-name)" })),
+            bundle_version: Type.Optional(Type.String({ description: "Published bundle version" })),
+            generation_status: optionalStringEnum(["published", "failed"], {
+              description: "Generation status: published or failed"
+            })
+          }),
+          execute: async (_toolCallId, args) => {
+            const account = resolveToolAccount();
+            const result = await updateRoleBundle(account, args.role_id, {
+              bundle_slug: args.bundle_slug,
+              bundle_version: args.bundle_version,
+              generation_status: args.generation_status
+            });
+            if (!result.ok) {
+              return {
+                content: [{ type: "text", text: `\u274C Failed to update role bundle: ${result.error}` }],
+                details: { ok: false, error: result.error }
+              };
+            }
+            const text = [
+              `\u2705 Role bundle updated!`,
+              args.bundle_slug ? `- **Bundle**: ${args.bundle_slug}` : "",
+              args.bundle_version ? `- **Version**: ${args.bundle_version}` : "",
+              args.generation_status ? `- **Status**: ${args.generation_status}` : ""
+            ].filter(Boolean).join("\n");
+            return {
+              content: [{ type: "text", text }],
+              details: { ok: true }
+            };
+          }
         }
       ];
     }),
@@ -3497,14 +3724,18 @@ function createRemotePlugin() {
         "**Replying**: When you reply to a task notification, your reply is posted as a comment on that task.",
         "",
         "**Available tools**:",
-        "- `remote_create_task` \u2014 Create a new task (title, type, priority, assigned_role_id, epic_id)",
-        "- `remote_update_task` \u2014 Update a task (status, priority, title, description, type, epic_id, assigned_role_id)",
+        "- `remote_create_task` \u2014 Create a new task (title, type, priority, assigned_role_id, epic_id, goal_id)",
+        "- `remote_update_task` \u2014 Update a task (status, priority, title, description, type, epic_id, goal_id, assigned_role_id)",
         "- `remote_list_tasks` \u2014 List/filter tasks on the board",
         "- `remote_board_health` \u2014 Get board health stats (task counts, epics, roles, recent activity)",
         "- `remote_list_roles` \u2014 List project roles with vacancy info (find valid assigned_role_id values)",
         "- `remote_list_epics` \u2014 List epics with task counts (find valid epic_id values)",
         "- `remote_create_epic` \u2014 Create a new epic (name, description, color)",
         "- `remote_list_team` \u2014 List all team members with roles and @mention handles",
+        "- `remote_list_goals` \u2014 List goals with progress (filter by status, parent_id, assigned_to)",
+        "- `remote_create_goal` \u2014 Create a goal (title, description, success_criteria, parent_id, owner_role_id, target_date)",
+        "- `remote_update_goal` \u2014 Update a goal (status, title, description, success_criteria, target_date, owner_role_id)",
+        "- `remote_update_role` \u2014 Update a role's bundle info (bundle_slug, bundle_version, generation_status)",
         "",
         "**Task lifecycle**: todo \u2192 in_progress \u2192 review \u2192 done",
         "**Task types**: feature, task, bug",
@@ -3518,7 +3749,10 @@ function createRemotePlugin() {
         "- Use `remote_list_roles` before creating tasks to find valid role IDs for assignment",
         "- Use `remote_list_epics` before creating tasks to find valid epic IDs for grouping",
         "- Use `remote_list_team` to find teammates and their @mention handles for tagging in comments",
-        "- Tag team members with @name in comments when you need their input or want to delegate"
+        "- Tag team members with @name in comments when you need their input or want to delegate",
+        "- Use `remote_list_goals` to see goal hierarchy and progress",
+        "- Goals auto-calculate progress from linked tasks (leaf goals) or child goals",
+        "- Link tasks to goals with goal_id when creating or updating tasks"
       ]
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-remote",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "Remote project board channel plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",
@@ -25,4 +25,4 @@
   "peerDependencies": {
     "openclaw": "*"
   }
-}
+}