@bubblelab/bubble-core 0.1.142 → 0.1.143

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/schema.d.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+import { CredentialType } from '@bubblelab/shared-schemas';
+export declare const AcceptedInvitationInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    headline: z.ZodOptional<z.ZodString>;
+    mutual_connections: z.ZodOptional<z.ZodString>;
+    profile_url: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    headline?: string | undefined;
+    profile_url?: string | undefined;
+    mutual_connections?: string | undefined;
+}, {
+    name: string;
+    headline?: string | undefined;
+    profile_url?: string | undefined;
+    mutual_connections?: string | undefined;
+}>;
+export type AcceptedInvitationInfo = z.infer<typeof AcceptedInvitationInfoSchema>;
+export declare const LinkedInAcceptInvitationsToolParamsSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"accept_invitations">;
+    count: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    credentials: z.ZodOptional<z.ZodRecord<z.ZodNativeEnum<typeof CredentialType>, z.ZodString>>;
+    proxy: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"none">;
+    }, "strip", z.ZodTypeAny, {
+        type: "none";
+    }, {
+        type: "none";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"browserbase">;
+    }, "strip", z.ZodTypeAny, {
+        type: "browserbase";
+    }, {
+        type: "browserbase";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        proxy: z.ZodObject<{
+            id: z.ZodString;
+            server: z.ZodString;
+            username: z.ZodOptional<z.ZodString>;
+            password: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            server: string;
+            password?: string | undefined;
+            username?: string | undefined;
+        }, {
+            id: string;
+            server: string;
+            password?: string | undefined;
+            username?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "custom";
+        proxy: {
+            id: string;
+            server: string;
+            password?: string | undefined;
+            username?: string | undefined;
+        };
+    }, {
+        type: "custom";
+        proxy: {
+            id: string;
+            server: string;
+            password?: string | undefined;
+            username?: string | undefined;
+        };
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    operation: "accept_invitations";
+    count: number;
+    credentials?: Partial<Record<CredentialType, string>> | undefined;
+    proxy?: {
+        type: "none";
+    } | {
+        type: "browserbase";
+    } | {
+        type: "custom";
+        proxy: {
+            id: string;
+            server: string;
+            password?: string | undefined;
+            username?: string | undefined;
+        };
+    } | undefined;
+}, {
+    operation: "accept_invitations";
+    credentials?: Partial<Record<CredentialType, string>> | undefined;
+    count?: number | undefined;
+    proxy?: {
+        type: "none";
+    } | {
+        type: "browserbase";
+    } | {
+        type: "custom";
+        proxy: {
+            id: string;
+            server: string;
+            password?: string | undefined;
+            username?: string | undefined;
+        };
+    } | undefined;
+}>;
+export declare const LinkedInAcceptInvitationsToolResultSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"accept_invitations">;
+    success: z.ZodBoolean;
+    accepted: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        headline: z.ZodOptional<z.ZodString>;
+        mutual_connections: z.ZodOptional<z.ZodString>;
+        profile_url: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        headline?: string | undefined;
+        profile_url?: string | undefined;
+        mutual_connections?: string | undefined;
+    }, {
+        name: string;
+        headline?: string | undefined;
+        profile_url?: string | undefined;
+        mutual_connections?: string | undefined;
+    }>, "many">>;
+    accepted_count: z.ZodOptional<z.ZodNumber>;
+    skipped_count: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    success: boolean;
+    operation: "accept_invitations";
+    message?: string | undefined;
+    accepted?: {
+        name: string;
+        headline?: string | undefined;
+        profile_url?: string | undefined;
+        mutual_connections?: string | undefined;
+    }[] | undefined;
+    accepted_count?: number | undefined;
+    skipped_count?: number | undefined;
+}, {
+    error: string;
+    success: boolean;
+    operation: "accept_invitations";
+    message?: string | undefined;
+    accepted?: {
+        name: string;
+        headline?: string | undefined;
+        profile_url?: string | undefined;
+        mutual_connections?: string | undefined;
+    }[] | undefined;
+    accepted_count?: number | undefined;
+    skipped_count?: number | undefined;
+}>;
+export type LinkedInAcceptInvitationsToolParamsInput = z.input<typeof LinkedInAcceptInvitationsToolParamsSchema>;
+export type LinkedInAcceptInvitationsToolResult = z.output<typeof LinkedInAcceptInvitationsToolResultSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAG3D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;EAOvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWpD,CAAC;AAEH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQpD,CAAC;AAEH,MAAM,MAAM,wCAAwC,GAAG,CAAC,CAAC,KAAK,CAC5D,OAAO,yCAAyC,CACjD,CAAC;AACF,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,MAAM,CACxD,OAAO,yCAAyC,CACjD,CAAC"}

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/schema.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { CredentialType } from '@bubblelab/shared-schemas';
+import { ProxyChoiceSchema } from '../_shared/schema.js';
+export const AcceptedInvitationInfoSchema = z.object({
+    name: z
+        .string()
+        .describe('Full name of the person whose invitation was accepted'),
+    headline: z.string().optional().describe('Professional headline/tagline'),
+    mutual_connections: z.string().optional().describe('Mutual connections info'),
+    profile_url: z.string().optional().describe('LinkedIn profile URL'),
+});
+export const LinkedInAcceptInvitationsToolParamsSchema = z.object({
+    operation: z.literal('accept_invitations'),
+    count: z
+        .number()
+        .min(1)
+        .max(100)
+        .optional()
+        .default(5)
+        .describe('Number of invitations to accept (default: 5, max: 100)'),
+    credentials: z.record(z.nativeEnum(CredentialType), z.string()).optional(),
+    proxy: ProxyChoiceSchema.optional(),
+});
+export const LinkedInAcceptInvitationsToolResultSchema = z.object({
+    operation: z.literal('accept_invitations'),
+    success: z.boolean(),
+    accepted: z.array(AcceptedInvitationInfoSchema).optional(),
+    accepted_count: z.number().optional(),
+    skipped_count: z.number().optional(),
+    message: z.string().optional(),
+    error: z.string(),
+});
+//# sourceMappingURL=schema.js.map

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../../src/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzD,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACnD,IAAI,EAAE,CAAC;SACJ,MAAM,EAAE;SACR,QAAQ,CAAC,uDAAuD,CAAC;IACpE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,+BAA+B,CAAC;IACzE,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yBAAyB,CAAC;IAC7E,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;CACpE,CAAC,CAAC;AAMH,MAAM,CAAC,MAAM,yCAAyC,GAAG,CAAC,CAAC,MAAM,CAAC;IAChE,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC;IAC1C,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,GAAG,CAAC;SACR,QAAQ,EAAE;SACV,OAAO,CAAC,CAAC,CAAC;SACV,QAAQ,CAAC,wDAAwD,CAAC;IACrE,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC1E,KAAK,EAAE,iBAAiB,CAAC,QAAQ,EAAE;CACpC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yCAAyC,GAAG,CAAC,CAAC,MAAM,CAAC;IAChE,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC;IAC1C,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC,QAAQ,EAAE;IAC1D,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACpC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;CAClB,CAAC,CAAC"}

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/tool.d.ts

@@ -0,0 +1,161 @@
+import { ToolBubble } from '../../../../types/tool-bubble-class.js';
+import type { BubbleContext } from '../../../../types/bubble.js';
+import { CredentialType } from '@bubblelab/shared-schemas';
+import { type LinkedInAcceptInvitationsToolParamsInput, type LinkedInAcceptInvitationsToolResult } from './schema.js';
+export declare class LinkedInAcceptInvitationsTool<T extends LinkedInAcceptInvitationsToolParamsInput = LinkedInAcceptInvitationsToolParamsInput> extends ToolBubble<T, LinkedInAcceptInvitationsToolResult> {
+    static readonly bubbleName: "linkedin-accept-invitations-tool";
+    static readonly schema: import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"accept_invitations">;
+        count: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        credentials: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodNativeEnum<typeof CredentialType>, import("zod").ZodString>>;
+        proxy: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"none">;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "none";
+        }, {
+            type: "none";
+        }>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"browserbase">;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "browserbase";
+        }, {
+            type: "browserbase";
+        }>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"custom">;
+            proxy: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                server: import("zod").ZodString;
+                username: import("zod").ZodOptional<import("zod").ZodString>;
+                password: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                id: string;
+                server: string;
+                password?: string | undefined;
+                username?: string | undefined;
+            }, {
+                id: string;
+                server: string;
+                password?: string | undefined;
+                username?: string | undefined;
+            }>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "custom";
+            proxy: {
+                id: string;
+                server: string;
+                password?: string | undefined;
+                username?: string | undefined;
+            };
+        }, {
+            type: "custom";
+            proxy: {
+                id: string;
+                server: string;
+                password?: string | undefined;
+                username?: string | undefined;
+            };
+        }>]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "accept_invitations";
+        count: number;
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        proxy?: {
+            type: "none";
+        } | {
+            type: "browserbase";
+        } | {
+            type: "custom";
+            proxy: {
+                id: string;
+                server: string;
+                password?: string | undefined;
+                username?: string | undefined;
+            };
+        } | undefined;
+    }, {
+        operation: "accept_invitations";
+        credentials?: Partial<Record<CredentialType, string>> | undefined;
+        count?: number | undefined;
+        proxy?: {
+            type: "none";
+        } | {
+            type: "browserbase";
+        } | {
+            type: "custom";
+            proxy: {
+                id: string;
+                server: string;
+                password?: string | undefined;
+                username?: string | undefined;
+            };
+        } | undefined;
+    }>;
+    static readonly resultSchema: import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"accept_invitations">;
+        success: import("zod").ZodBoolean;
+        accepted: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            headline: import("zod").ZodOptional<import("zod").ZodString>;
+            mutual_connections: import("zod").ZodOptional<import("zod").ZodString>;
+            profile_url: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            name: string;
+            headline?: string | undefined;
+            profile_url?: string | undefined;
+            mutual_connections?: string | undefined;
+        }, {
+            name: string;
+            headline?: string | undefined;
+            profile_url?: string | undefined;
+            mutual_connections?: string | undefined;
+        }>, "many">>;
+        accepted_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        skipped_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        message: import("zod").ZodOptional<import("zod").ZodString>;
+        error: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        operation: "accept_invitations";
+        error: string;
+        success: boolean;
+        message?: string | undefined;
+        accepted?: {
+            name: string;
+            headline?: string | undefined;
+            profile_url?: string | undefined;
+            mutual_connections?: string | undefined;
+        }[] | undefined;
+        accepted_count?: number | undefined;
+        skipped_count?: number | undefined;
+    }, {
+        operation: "accept_invitations";
+        error: string;
+        success: boolean;
+        message?: string | undefined;
+        accepted?: {
+            name: string;
+            headline?: string | undefined;
+            profile_url?: string | undefined;
+            mutual_connections?: string | undefined;
+        }[] | undefined;
+        accepted_count?: number | undefined;
+        skipped_count?: number | undefined;
+    }>;
+    static readonly shortDescription = "Accept top N LinkedIn connection invitations";
+    static readonly longDescription = "Navigates to the LinkedIn invitation manager page and accepts the top N received connection invitations. Returns info about each accepted invitation.";
+    static readonly alias = "linkedin-accept-invitations";
+    static readonly type = "tool";
+    private sessionId;
+    private contextId;
+    private cookies;
+    constructor(params?: T, context?: BubbleContext);
+    protected chooseCredential(): string | undefined;
+    private stepStartBrowserSession;
+    private stepNavigateToInvitationManager;
+    private stepWaitForInvitationsPage;
+    private stepAcceptTopInvitations;
+    private stepEndBrowserSession;
+    private evaluate;
+    private detectIPAddress;
+    performAction(): Promise<LinkedInAcceptInvitationsToolResult>;
+}
+//# sourceMappingURL=tool.d.ts.map

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../../../src/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAKjE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAGL,KAAK,wCAAwC,EAC7C,KAAK,mCAAmC,EAEzC,MAAM,aAAa,CAAC;AAErB,qBAAa,6BAA6B,CACxC,CAAC,SACC,wCAAwC,GAAG,wCAAwC,CACrF,SAAQ,UAAU,CAAC,CAAC,EAAE,mCAAmC,CAAC;IAC1D,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAG,kCAAkC,CAAU;IACzE,MAAM,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA6C;IACnE,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA6C;IACzE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,kDACiB;IACjD,MAAM,CAAC,QAAQ,CAAC,eAAe,2JAC2H;IAC1J,MAAM,CAAC,QAAQ,CAAC,KAAK,iCAAiC;IACtD,MAAM,CAAC,QAAQ,CAAC,IAAI,UAAU;IAE9B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,OAAO,CAA4B;gBAGzC,MAAM,GAAE,CAA4C,EACpD,OAAO,CAAC,EAAE,aAAa;IAKzB,SAAS,CAAC,gBAAgB,IAAI,MAAM,GAAG,SAAS;YAOlC,uBAAuB;YAgCvB,+BAA+B;YAkB/B,0BAA0B;YAqB1B,wBAAwB;YAkLxB,qBAAqB;YAYrB,QAAQ;YAaR,eAAe;IAiBvB,aAAa,IAAI,OAAO,CAAC,mCAAmC,CAAC;CA+BpE"}

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/tool.js

@@ -0,0 +1,310 @@
+import { ToolBubble } from '../../../../types/tool-bubble-class.js';
+import { BrowserBaseBubble, } from '../../../service-bubble/browserbase/index.js';
+import { CredentialType } from '@bubblelab/shared-schemas';
+import { parseBrowserSessionData, buildProxyConfig } from '../_shared/utils.js';
+import { LinkedInAcceptInvitationsToolParamsSchema, LinkedInAcceptInvitationsToolResultSchema, } from './schema.js';
+export class LinkedInAcceptInvitationsTool extends ToolBubble {
+    static bubbleName = 'linkedin-accept-invitations-tool';
+    static schema = LinkedInAcceptInvitationsToolParamsSchema;
+    static resultSchema = LinkedInAcceptInvitationsToolResultSchema;
+    static shortDescription = 'Accept top N LinkedIn connection invitations';
+    static longDescription = 'Navigates to the LinkedIn invitation manager page and accepts the top N received connection invitations. Returns info about each accepted invitation.';
+    static alias = 'linkedin-accept-invitations';
+    static type = 'tool';
+    sessionId = null;
+    contextId = null;
+    cookies = null;
+    constructor(params = { operation: 'accept_invitations' }, context) {
+        super(params, context);
+    }
+    chooseCredential() {
+        const { credentials } = this.params;
+        return credentials?.[CredentialType.LINKEDIN_CRED];
+    }
+    async stepStartBrowserSession() {
+        if (this.sessionId)
+            return;
+        const sessionData = parseBrowserSessionData(this.chooseCredential());
+        if (sessionData) {
+            this.contextId = sessionData.contextId;
+            this.cookies = sessionData.cookies;
+        }
+        const proxyConfig = buildProxyConfig(this.params.proxy);
+        const browserbase = new BrowserBaseBubble({
+            operation: 'start_session',
+            context_id: this.contextId || undefined,
+            cookies: this.cookies || undefined,
+            credentials: this.params.credentials,
+            stealth: { solveCaptchas: true },
+            timeout_seconds: 600,
+            ...proxyConfig,
+        }, this.context, 'startsession');
+        const result = await browserbase.action();
+        if (!result.data.success || !result.data.session_id) {
+            throw new Error(result.data.error || 'Failed to start browser session');
+        }
+        this.sessionId = result.data.session_id;
+        if (result.data.context_id)
+            this.contextId = result.data.context_id;
+        console.log(`[AcceptInvitations] Session started: ${this.sessionId}`);
+        const ip = await this.detectIPAddress();
+        if (ip)
+            console.log(`[AcceptInvitations] Browser IP: ${ip}`);
+    }
+    async stepNavigateToInvitationManager() {
+        if (!this.sessionId)
+            throw new Error('No active session');
+        const browserbase = new BrowserBaseBubble({
+            operation: 'navigate',
+            session_id: this.sessionId,
+            url: 'https://www.linkedin.com/mynetwork/invitation-manager/',
+            wait_until: 'domcontentloaded',
+            timeout: 30000,
+        }, this.context, 'navigate');
+        const result = await browserbase.action();
+        if (!result.data.success)
+            throw new Error(result.data.error || 'Navigation failed');
+    }
+    async stepWaitForInvitationsPage() {
+        const checkScript = `(() => {
+      const buttons = document.querySelectorAll('button');
+      let hasAcceptButton = false;
+      for (const btn of buttons) {
+        if ((btn.innerText || btn.textContent || '').trim().toLowerCase() === 'accept') {
+          hasAcceptButton = true;
+          break;
+        }
+      }
+      const peopleLabel = document.body.innerText.match(/People\\s*\\(\\d+\\)/i);
+      return hasAcceptButton || !!peopleLabel;
+    })()`;
+        for (let attempt = 1; attempt <= 15; attempt++) {
+            const found = await this.evaluate(checkScript);
+            if (found)
+                return true;
+            await new Promise((r) => setTimeout(r, 1000));
+        }
+        return false;
+    }
+    async stepAcceptTopInvitations(count) {
+        const accepted = [];
+        let skipped = 0;
+        const TEMP_ID = '__bubblelab_accept_target__';
+        for (let i = 0; i < count; i++) {
+            // Step 1: Find first visible Accept button, extract card info, tag it with a temp ID
+            const extractResult = (await this.evaluate(`
+        (() => {
+          // Clean up any previous temp ID
+          const prev = document.getElementById('${TEMP_ID}');
+          if (prev) prev.removeAttribute('id');
+
+          const acceptButtons = Array.from(document.querySelectorAll('button')).filter(btn => {
+            const text = (btn.innerText || btn.textContent || '').trim().toLowerCase();
+            return text === 'accept' && btn.offsetParent !== null && !btn.disabled;
+          });
+          if (acceptButtons.length === 0) return { done: true, buttonCount: 0 };
+
+          const acceptBtn = acceptButtons[0];
+
+          // Tag the button with a temp ID so Puppeteer can click it precisely
+          acceptBtn.id = '${TEMP_ID}';
+
+          // Scroll the button into view
+          acceptBtn.scrollIntoView({ block: 'center', behavior: 'instant' });
+
+          // Walk up to find the invitation card container
+          let container = acceptBtn.parentElement;
+          for (let j = 0; j < 10 && container; j++) {
+            const text = container.innerText || '';
+            const hasProfileLink = !!container.querySelector('a[href*="/in/"]');
+            const hasTimeText = !!(text.match(/\\d+\\s+(hour|day|week|month|minute|second)s?\\s+ago/i) || text.match(/Yesterday/i));
+            if (hasProfileLink && hasTimeText) break;
+            container = container.parentElement;
+          }
+
+          let name = '';
+          let headline = '';
+          let mutual_connections = '';
+          let profile_url = '';
+
+          if (container) {
+            const links = container.querySelectorAll('a[href*="/in/"]');
+            for (const link of links) {
+              const href = link.getAttribute('href') || '';
+              if (href.includes('/in/')) {
+                profile_url = href.startsWith('http') ? href : 'https://www.linkedin.com' + href;
+                break;
+              }
+            }
+            for (const link of links) {
+              const linkText = (link.innerText || link.textContent || '').trim();
+              if (linkText && linkText.length > 1 && linkText.length < 100) {
+                name = linkText;
+                break;
+              }
+            }
+            if (!name) {
+              const spans = container.querySelectorAll('span');
+              for (const span of spans) {
+                const spanText = (span.innerText || span.textContent || '').trim();
+                if (spanText && spanText.length > 2 && spanText.length < 50 &&
+                    !spanText.includes('Accept') && !spanText.includes('Ignore') &&
+                    !spanText.includes('mutual') && !spanText.includes('ago') &&
+                    !spanText.includes('Yesterday')) {
+                  name = spanText;
+                  break;
+                }
+              }
+            }
+
+            const containerText = container.innerText || '';
+            const mutualMatch = containerText.match(/(.+?(?:mutual connection|mutual connections))/i);
+            if (mutualMatch) mutual_connections = mutualMatch[0].trim();
+
+            const lines = containerText.split('\\n').map(l => l.trim()).filter(l => l);
+            let nameLineIdx = -1, endLineIdx = -1;
+            for (let k = 0; k < lines.length; k++) {
+              if (lines[k] === name) nameLineIdx = k;
+              if (endLineIdx === -1 && (
+                lines[k].match(/\\d+\\s+(hour|day|week|month|minute|second)s?\\s+ago/i) ||
+                lines[k].match(/Yesterday/i) ||
+                lines[k].match(/mutual connection/i)
+              )) endLineIdx = k;
+            }
+            if (nameLineIdx >= 0 && endLineIdx > nameLineIdx + 1) {
+              headline = lines.slice(nameLineIdx + 1, endLineIdx)
+                .filter(l => l.toLowerCase() !== 'accept' && l.toLowerCase() !== 'ignore' && l.length > 3)
+                .join(' ').trim();
+            }
+            if (!headline) {
+              for (const line of lines) {
+                if (line === name || line.toLowerCase() === 'accept' || line.toLowerCase() === 'ignore' ||
+                    line.match(/\\d+\\s+(hour|day|week|month|minute|second)s?\\s+ago/i) ||
+                    line.match(/Yesterday/i) || line.match(/mutual connection/i) ||
+                    line.match(/^People\\s*\\(/i) || line.match(/^Message$/i)) continue;
+                if (line.length > 10 && line.length < 300) { headline = line; break; }
+              }
+            }
+          }
+
+          return {
+            done: false,
+            buttonCount: acceptButtons.length,
+            info: {
+              name: name || 'Unknown',
+              headline: headline || undefined,
+              mutual_connections: mutual_connections || undefined,
+              profile_url: profile_url || undefined,
+            }
+          };
+        })()
+      `));
+            if (extractResult.done) {
+                console.log(`[AcceptInvitations] No more invitations to accept after ${accepted.length}`);
+                break;
+            }
+            const prevButtonCount = extractResult.buttonCount;
+            // Step 2: Click the tagged button using BrowserBase (Puppeteer trusted click)
+            if (!this.sessionId)
+                throw new Error('No active session');
+            const clickBubble = new BrowserBaseBubble({
+                operation: 'click',
+                session_id: this.sessionId,
+                selector: `#${TEMP_ID}`,
+                wait_for_navigation: false,
+                timeout: 5000,
+            }, this.context, 'clickaccept');
+            const clickResult = await clickBubble.action();
+            if (!clickResult.data.success) {
+                console.log(`[AcceptInvitations] Click failed for invitation ${i + 1}, skipping`);
+                skipped++;
+                await new Promise((r) => setTimeout(r, 1000));
+                continue;
+            }
+            if (extractResult.info) {
+                accepted.push(extractResult.info);
+                console.log(`[AcceptInvitations] Accepted ${i + 1}/${count}: ${extractResult.info.name}`);
+            }
+            // Step 3: Wait for DOM to update — poll until Accept button count decreases
+            const MAX_WAIT_POLLS = 15;
+            for (let poll = 0; poll < MAX_WAIT_POLLS; poll++) {
+                await new Promise((r) => setTimeout(r, 500));
+                const currentCount = (await this.evaluate(`
+          Array.from(document.querySelectorAll('button')).filter(btn => {
+            const text = (btn.innerText || btn.textContent || '').trim().toLowerCase();
+            return text === 'accept' && btn.offsetParent !== null && !btn.disabled;
+          }).length
+        `));
+                if (currentCount < prevButtonCount)
+                    break;
+            }
+        }
+        return { accepted, skipped };
+    }
+    async stepEndBrowserSession() {
+        if (!this.sessionId)
+            return;
+        const browserbase = new BrowserBaseBubble({ operation: 'end_session', session_id: this.sessionId }, this.context, 'endsession');
+        await browserbase.action();
+        console.log(`[AcceptInvitations] Session ended: ${this.sessionId}`);
+        this.sessionId = null;
+    }
+    async evaluate(script) {
+        if (!this.sessionId)
+            throw new Error('No active session');
+        const browserbase = new BrowserBaseBubble({ operation: 'evaluate', session_id: this.sessionId, script }, this.context, 'evaluate');
+        const result = await browserbase.action();
+        if (!result.data.success)
+            throw new Error(result.data.error || 'Evaluation failed');
+        return result.data.result;
+    }
+    async detectIPAddress() {
+        if (!this.sessionId)
+            return null;
+        try {
+            return (await this.evaluate(`
+        (async () => {
+          try {
+            const r = await fetch('https://api.ipify.org?format=json');
+            const d = await r.json();
+            return d.ip;
+          } catch { return null; }
+        })()
+      `));
+        }
+        catch {
+            return null;
+        }
+    }
+    async performAction() {
+        const count = this.params.count ?? 5;
+        try {
+            await this.stepStartBrowserSession();
+            await this.stepNavigateToInvitationManager();
+            const pageReady = await this.stepWaitForInvitationsPage();
+            if (!pageReady)
+                console.log('[AcceptInvitations] Page slow to load, continuing');
+            const { accepted, skipped } = await this.stepAcceptTopInvitations(count);
+            return {
+                operation: 'accept_invitations',
+                success: true,
+                accepted,
+                accepted_count: accepted.length,
+                skipped_count: skipped,
+                message: `Accepted ${accepted.length} invitation(s)${skipped > 0 ? `, skipped ${skipped}` : ''}`,
+                error: '',
+            };
+        }
+        catch (error) {
+            return {
+                operation: 'accept_invitations',
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+        finally {
+            await this.stepEndBrowserSession();
+        }
+    }
+}
+//# sourceMappingURL=tool.js.map