@agnocon/piece-browse-ai 0.1.7

package/src/lib/common/props.ts

@@ -0,0 +1,213 @@
+import { DynamicPropsValue, Property } from '@agnocon/pieces-framework';
+import { HttpMethod } from '@agnocon/pieces-common';
+import { browseAiApiCall } from './client';
+import { browseAiAuth } from './auth';
+
+interface BrowseAiRobot {
+  id: string;
+  name: string;
+}
+
+interface BrowseAiTask {
+  id: string;
+  status: string;
+  createdAt?: number;
+}
+
+interface BrowseAiTasksResponse {
+  statusCode: number;
+  messageCode: string;
+  result: {
+    robotTasks: {
+      totalCount: number;
+      pageNumber: number;
+      hasMore: boolean;
+      items: BrowseAiTask[];
+    };
+  };
+}
+
+interface BrowseAiRobotResponse {
+  robot: {
+    id: string;
+    name: string;
+    inputParameters: {
+      type: string;
+      name: string;
+      label: string;
+      required: boolean;
+      options?: { label: string; value: string }[];
+    }[];
+  };
+}
+
+export const robotIdDropdown = Property.Dropdown({
+  auth: browseAiAuth,
+  displayName: 'Robot',
+  description: 'Select a robot from your Browse AI account',
+  required: true,
+  refreshers: [],
+  options: async ({ auth }) => {
+    if (!auth) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder: 'Please connect your Browse AI account first.',
+      };
+    }
+
+    try {
+      const response = await browseAiApiCall<{
+        robots: { items: BrowseAiRobot[] };
+      }>({
+        method: HttpMethod.GET,
+        resourceUri: '/robots',
+        auth: { apiKey: auth.secret_text },
+      });
+
+      const robots = response?.robots?.items ?? [];
+
+      if (robots.length === 0) {
+        return {
+          disabled: true,
+          options: [],
+          placeholder: 'No robots found in your account.',
+        };
+      }
+
+      return {
+        disabled: false,
+        options: robots.map((robot) => ({
+          label: robot.name,
+          value: robot.id,
+        })),
+      };
+    } catch (error: any) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder:
+          'Failed to load robots. Please check your API key and try again.',
+      };
+    }
+  },
+});
+
+export const taskIdDropdown = Property.Dropdown({
+  auth: browseAiAuth,
+  displayName: 'Task',
+  description: 'Select a task associated with the selected robot',
+  required: true,
+  refreshers: ['robotId'],
+  options: async ({ auth, robotId }) => {
+    if (!auth) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder: 'Please connect your Browse AI account.',
+      };
+    }
+
+    if (!robotId) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder: 'Please select a robot first.',
+      };
+    }
+
+    try {
+      const response = await browseAiApiCall<BrowseAiTasksResponse>({
+        method: HttpMethod.GET,
+        resourceUri: `/robots/${robotId}/tasks`,
+        auth: { apiKey: auth.secret_text },
+      });
+
+      const tasks = response.result?.robotTasks?.items ?? [];
+
+      if (tasks.length === 0) {
+        return {
+          disabled: true,
+          options: [],
+          placeholder: 'No tasks found for the selected robot.',
+        };
+      }
+
+      return {
+        disabled: false,
+        options: tasks.map((task) => {
+          const createdDate = task.createdAt
+            ? new Date(task.createdAt).toLocaleDateString()
+            : 'Unknown date';
+          return {
+            label: `${task.id} - ${task.status} (${createdDate})`,
+            value: task.id,
+          };
+        }),
+      };
+    } catch (e) {
+      return {
+        disabled: true,
+        options: [],
+        placeholder: `Error fetching tasks: ${
+          e instanceof Error ? e.message : 'Unknown error'
+        }`,
+      };
+    }
+  },
+});
+
+export const robotParameters = Property.DynamicProperties({
+  auth: browseAiAuth,
+  displayName: 'Input Parameters',
+  refreshers: ['robotId'],
+  required: true,
+  props: async ({ auth, robotId }) => {
+    if (!auth || !robotId) return {};
+
+    try {
+      const response = await browseAiApiCall<BrowseAiRobotResponse>({
+        method: HttpMethod.GET,
+        resourceUri: `/robots/${robotId}`,
+        auth: { apiKey: auth.secret_text },
+      });
+
+      const props: DynamicPropsValue = {};
+
+      const params = response.robot.inputParameters ?? [];
+
+      for (const param of params) {
+        switch (param.type) {
+          case 'number':
+            props[param.name] = Property.Number({
+              displayName: param.label,
+              required: param.required,
+            });
+            break;
+          case 'url':
+          case 'string':
+            props[param.name] = Property.ShortText({
+              displayName: param.label,
+              required: param.required,
+            });
+            break;
+          case 'select':
+            props[param.name] = Property.StaticDropdown({
+              displayName: param.label,
+              required: param.required,
+              options: {
+                disabled: false,
+                options: param.options ? param.options : [],
+              },
+            });
+            break;
+          default:
+            break;
+        }
+      }
+      return props;
+    } catch {
+      return {};
+    }
+  },
+});

package/src/lib/triggers/task-finished-successfully.ts

@@ -0,0 +1,139 @@
+import { HttpMethod } from '@agnocon/pieces-common';
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { isNil } from '@agnocon/pieces-framework';
+import { browseAiAuth } from '../common/auth';
+import { browseAiApiCall } from '../common/client';
+import { robotIdDropdown } from '../common/props';
+
+const TRIGGER_KEY = 'browse-ai-task_finished_successfully';
+
+export const taskFinishedSuccessfullyTrigger = createTrigger({
+  auth: browseAiAuth,
+  name: 'task_finished_successfully',
+  displayName: 'Task Finished Successfully',
+  description:
+    'Triggers when a robot finishes a task successfully.',
+  aiMetadata: {
+    description:
+      'Fires when a task run for the selected Browse AI robot completes successfully, delivering the finished task record with its captured/extracted data. Use to process scrape results as soon as they are ready.',
+  },
+  type: TriggerStrategy.WEBHOOK,
+  props: {
+    robotId: robotIdDropdown,
+  },
+
+  async onEnable(context) {
+    const { robotId } = context.propsValue;
+    const apiKey = context.auth.secret_text;
+
+    try {
+      // Verify robot exists and we have access
+      await browseAiApiCall({
+        method: HttpMethod.GET,
+        auth: { apiKey },
+        resourceUri: `/robots/${robotId}`,
+      });
+
+      const response = await browseAiApiCall<{
+        webhook: { id: string; url: string; status: string };
+      }>({
+        method: HttpMethod.POST,
+        auth: { apiKey },
+        resourceUri: `/robots/${robotId}/webhooks`,
+        body: {
+          hookUrl: context.webhookUrl,
+          eventType: 'taskFinishedSuccessfully',
+        },
+      });
+
+      await context.store.put<string>(TRIGGER_KEY, response.webhook.id);
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        throw new Error(
+          `Robot not found: The robot with ID "${robotId}" does not exist or you do not have access to it. Please verify the robot ID and your permissions.`
+        );
+      }
+
+      if (error.response?.status === 403) {
+        throw new Error(
+          'Access denied: You do not have permission to set up webhooks for this robot. Please check your Browse AI account permissions and ensure you have webhook access.'
+        );
+      }
+
+      if (error.response?.status === 400) {
+        throw new Error(
+          `Invalid webhook configuration: ${
+            error.response?.data?.message || error.message
+          }. Please check your webhook URL and robot ID.`
+        );
+      }
+
+      if (error.response?.status === 429) {
+        throw new Error(
+          'Rate limit exceeded: Too many webhook requests. Please wait a moment and try again.'
+        );
+      }
+
+      throw new Error(
+        `Failed to set up webhook: ${
+          error.message || 'Unknown error occurred'
+        }. Please check your robot ID and try again.`
+      );
+    }
+  },
+
+  async onDisable(context) {
+    const { robotId } = context.propsValue;
+
+    const webhookId = await context.store.get<string>(TRIGGER_KEY);
+    const apiKey = context.auth.secret_text;
+
+    if (!isNil(webhookId)) {
+      try {
+        await browseAiApiCall({
+          method: HttpMethod.DELETE,
+          auth: { apiKey },
+          resourceUri: `/robots/${robotId}/webhooks/${webhookId}`,
+        });
+      } catch (error: any) {
+        console.warn(
+          `Warning: Failed to clean up webhook ${webhookId}:`,
+          error.message
+        );
+
+        // Clean up the stored webhook ID even if deletion failed
+        await context.store.delete(TRIGGER_KEY);
+      }
+    }
+  },
+
+  async run(context) {
+    const payload = context.payload.body as {
+      task: Record<string, any>;
+      event: string;
+    };
+
+    if (payload.event !== 'task.finishedSuccessfully') return [];
+
+    return [payload.task];
+  },
+
+  async test(context) {
+    const { robotId } = context.propsValue;
+
+    const apiKey = context.auth.secret_text;
+
+    const response = await browseAiApiCall<{
+      result: { robotTasks: { items: { id: string }[] } };
+    }>({
+      method: HttpMethod.GET,
+      auth: { apiKey },
+      resourceUri: `/robots/${robotId}/tasks`,
+      query: { status: 'successful', sort: '-createdAt' },
+    });
+
+    return response.result.robotTasks.items;
+  },
+
+  sampleData: {},
+});

package/src/lib/triggers/task-finished-with-error.ts

@@ -0,0 +1,138 @@
+import { HttpMethod } from '@agnocon/pieces-common';
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { isNil } from '@agnocon/pieces-framework';
+import { browseAiAuth } from '../common/auth';
+import { browseAiApiCall } from '../common/client';
+import { robotIdDropdown } from '../common/props';
+
+const TRIGGER_KEY = 'browse-ai-task_finished_with_error';
+
+export const taskFinishedWithErrorTrigger = createTrigger({
+  auth: browseAiAuth,
+  name: 'task_finished_with_error',
+  displayName: 'Task Finished with Error',
+  description: 'Triggers when a robot task run fails with an error.',
+  aiMetadata: {
+    description:
+      'Fires when a task run for the selected Browse AI robot finishes in a failed/error state, delivering the failed task record. Use to detect and react to scrapes that did not complete successfully.',
+  },
+  type: TriggerStrategy.WEBHOOK,
+  props: {
+    robotId: robotIdDropdown,
+  },
+
+  async onEnable(context) {
+    const { robotId } = context.propsValue;
+    const apiKey = context.auth.secret_text;
+
+    try {
+      // Verify robot exists and we have access
+      await browseAiApiCall({
+        method: HttpMethod.GET,
+        auth: { apiKey },
+        resourceUri: `/robots/${robotId}`,
+      });
+
+      const response = await browseAiApiCall<{
+        webhook: { id: string; url: string; status: string };
+      }>({
+        method: HttpMethod.POST,
+        auth: { apiKey },
+        resourceUri: `/robots/${robotId}/webhooks`,
+        body: {
+          hookUrl: context.webhookUrl,
+          eventType: 'taskFinishedWithError',
+        },
+      });
+
+      await context.store.put<string>(TRIGGER_KEY, response.webhook.id);
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        throw new Error(
+          `Robot not found: The robot with ID "${robotId}" does not exist or you do not have access to it. Please verify the robot ID and your permissions.`
+        );
+      }
+
+      if (error.response?.status === 403) {
+        throw new Error(
+          'Access denied: You do not have permission to set up webhooks for this robot. Please check your Browse AI account permissions and ensure you have webhook access.'
+        );
+      }
+
+      if (error.response?.status === 400) {
+        throw new Error(
+          `Invalid webhook configuration: ${
+            error.response?.data?.message || error.message
+          }. Please check your webhook URL and robot ID.`
+        );
+      }
+
+      if (error.response?.status === 429) {
+        throw new Error(
+          'Rate limit exceeded: Too many webhook requests. Please wait a moment and try again.'
+        );
+      }
+
+      throw new Error(
+        `Failed to set up webhook: ${
+          error.message || 'Unknown error occurred'
+        }. Please check your robot ID and try again.`
+      );
+    }
+  },
+
+  async onDisable(context) {
+    const { robotId } = context.propsValue;
+
+    const webhookId = await context.store.get<string>(TRIGGER_KEY);
+    const apiKey = context.auth.secret_text;
+
+    if (!isNil(webhookId)) {
+      try {
+        await browseAiApiCall({
+          method: HttpMethod.DELETE,
+          auth: { apiKey },
+          resourceUri: `/robots/${robotId}/webhooks/${webhookId}`,
+        });
+      } catch (error: any) {
+        console.warn(
+          `Warning: Failed to clean up webhook ${webhookId}:`,
+          error.message
+        );
+
+        // Clean up the stored webhook ID even if deletion failed
+        await context.store.delete(TRIGGER_KEY);
+      }
+    }
+  },
+
+  async run(context) {
+    const payload = context.payload.body as {
+      task: Record<string, any>;
+      event: string;
+    };
+
+    if (payload.event !== 'task.finishedWithError') return [];
+
+    return [payload.task];
+  },
+
+  async test(context) {
+    const { robotId } = context.propsValue;
+
+    const apiKey = context.auth.secret_text;
+
+    const response = await browseAiApiCall<{
+      result: { robotTasks: { items: { id: string }[] } };
+    }>({
+      method: HttpMethod.GET,
+      auth: { apiKey },
+      resourceUri: `/robots/${robotId}/tasks`,
+      query: { status: 'failed', sort: '-createdAt' },
+    });
+
+    return response.result.robotTasks.items;
+  },
+
+  sampleData: {},
+});