@hraness/ghostget 0.17.2

package/src/providers/linkedin-profile-activity-failure.ts

@@ -0,0 +1,76 @@
+import { OperationDeadlineError } from "../operation-deadline";
+import { readFailureProjection, type ReadFailureProjection } from "../web-session-execution";
+import {
+  LinkedInFeedBrowserFailure,
+  LinkedInFeedBrowserResponseRejectedError,
+} from "./linkedin-web-feed-browser";
+
+export type LinkedInProfileActivityStage = "identity" | "binding" | "page" | "projection";
+
+/** Only the account-binding producer creates this category. Native wording is
+ * diagnostic data and cannot authorize account mismatch or auth repair. */
+export class LinkedInProfileActivityIdentityMismatch extends Error {
+  constructor(cause: unknown) {
+    super("LinkedIn current member no longer matches the bound auth subject", { cause });
+    this.name = "LinkedInProfileActivityIdentityMismatch";
+  }
+}
+
+export function linkedInProfileActivityReadFailure(
+  error: unknown,
+  stage: LinkedInProfileActivityStage,
+): ReadFailureProjection {
+  let deadlineCause: unknown = error;
+  for (let depth = 0; depth < 8 && deadlineCause !== undefined; depth += 1) {
+    if (deadlineCause instanceof OperationDeadlineError) {
+      return readFailureProjection(deadlineCause.failure === "timed-out" ? "operation-timeout" : "contract-drift");
+    }
+    deadlineCause = deadlineCause instanceof Error ? deadlineCause.cause : undefined;
+  }
+  let current: unknown = error;
+  for (let depth = 0; depth < 8 && current !== undefined; depth += 1) {
+    if (current instanceof LinkedInProfileActivityIdentityMismatch) return readFailureProjection("account-mismatch");
+    if (current instanceof LinkedInFeedBrowserResponseRejectedError) {
+      if (current.status === 401 || current.status === 403) return readFailureProjection("auth-repair-required");
+      if (current.status === 429) return readFailureProjection("provider-throttled");
+      if (current.status === 302 || current.status === 408 || current.status >= 500) return readFailureProjection("provider-temporary");
+      if (current.status === 404 && stage !== "identity") return readFailureProjection("target-unavailable");
+      return readFailureProjection("contract-drift");
+    }
+    if (current instanceof LinkedInFeedBrowserFailure) {
+      if (current.category === "authwall" || current.category === "session-cookie") return readFailureProjection("auth-repair-required");
+      if (current.category === "startup" || current.category === "execution-context" || current.category === "provider-fetch") {
+        return readFailureProjection("provider-temporary");
+      }
+      return readFailureProjection("contract-drift");
+    }
+    current = current instanceof Error ? current.cause : undefined;
+  }
+  return readFailureProjection("contract-drift");
+}
+
+const REQUEST_STAGE: Readonly<Record<LinkedInProfileActivityStage, string>> = {
+  identity: "contained-browser signed-in identity preflight",
+  binding: "contained-browser profile-activity query observation",
+  page: "contained-browser profile-activity page read",
+  projection: "exact profile-activity projection",
+};
+
+export function linkedInProfileActivityDiagnostic(error: unknown, stage: LinkedInProfileActivityStage): string {
+  let category = stage === "binding" ? "live query observation"
+    : stage === "projection" ? "exact page projection" : "reviewed response projection";
+  let current: unknown = error;
+  for (let depth = 0; depth < 8 && current !== undefined; depth += 1) {
+    if (current instanceof LinkedInProfileActivityIdentityMismatch) {
+      category = "signed-in account binding";
+      break;
+    }
+    if (current instanceof LinkedInFeedBrowserFailure) {
+      if (current.category === "authwall") category = "signed-out authwall";
+      if (current.category === "session-cookie") category = "signed-in session cookie";
+      break;
+    }
+    current = current instanceof Error ? current.cause : undefined;
+  }
+  return `LinkedIn profile-activity read failed during ${REQUEST_STAGE[stage]} at ${category}; no remote write occurred`;
+}

package/src/providers/linkedin-profile-activity-platform.ts

@@ -0,0 +1,41 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { ReadEffectFailure, readAttempt } from "../read-effect";
+import { readNative } from "../read-effect-platform";
+import type { LinkedInFeedBrowserTransport } from "./linkedin-web-feed-browser";
+import { LinkedInProfileActivityIdentityMismatch } from "./linkedin-profile-activity-failure";
+
+export type LinkedInProfileActivityIdentity = { readonly subject: string };
+
+export type LinkedInProfileActivityNative = {
+  readonly openBrowser: () => Promise<LinkedInFeedBrowserTransport>;
+  readonly decodeIdentity: (value: unknown) => LinkedInProfileActivityIdentity;
+  readonly bindIdentity: (identity: LinkedInProfileActivityIdentity) => string;
+  readonly observedAt: () => string;
+};
+
+function platform(ports: LinkedInProfileActivityNative) {
+  return {
+    openBrowser: readNative(ports.openBrowser).pipe(Effect.uninterruptible),
+    identity: (browser: LinkedInFeedBrowserTransport) => readNative(() => browser.currentIdentityResponse()).pipe(
+      Effect.uninterruptible,
+      Effect.flatMap(value => readAttempt(() => ports.decodeIdentity(value))),
+    ),
+    bindIdentity: (identity: LinkedInProfileActivityIdentity) => readAttempt(() => ports.bindIdentity(identity)).pipe(
+      Effect.mapError(error => new ReadEffectFailure({ cause: new LinkedInProfileActivityIdentityMismatch(error.cause) })),
+    ),
+    binding: (browser: LinkedInFeedBrowserTransport, slug: string) => readNative(() => browser.resolveProfileActivityBinding(slug)).pipe(Effect.uninterruptible),
+    page: (browser: LinkedInFeedBrowserTransport, count: number, start: number) => readNative(() => browser.readProfileActivityPage({ count, start })).pipe(Effect.uninterruptible),
+    observedAt: readAttempt(ports.observedAt),
+    closeBrowser: (browser: LinkedInFeedBrowserTransport) => readNative(() => browser.close()).pipe(Effect.uninterruptible),
+  };
+}
+
+export class LinkedInProfileActivityPlatform extends Context.Tag("wrench/LinkedInProfileActivityPlatform/v1")<
+  LinkedInProfileActivityPlatform,
+  ReturnType<typeof platform>
+>() { }
+
+export const LinkedInProfileActivityPlatformLive = (ports: LinkedInProfileActivityNative): Layer.Layer<LinkedInProfileActivityPlatform> =>
+  Layer.succeed(LinkedInProfileActivityPlatform, platform(ports));

package/src/providers/linkedin-profile-activity-program.ts

@@ -0,0 +1,67 @@
+import * as Effect from "effect/Effect";
+import { PreservedBrowserArtifactsError } from "../browser";
+import { readAttempt, type ReadEffectFailure, withReadResource } from "../read-effect";
+import type { WebSessionExecution } from "../web-session-execution";
+import { LinkedInProfileActivityPlatform } from "./linkedin-profile-activity-platform";
+import {
+  linkedInProfileActivityDiagnostic,
+  linkedInProfileActivityReadFailure,
+  type LinkedInProfileActivityStage,
+} from "./linkedin-profile-activity-failure";
+import {
+  projectLinkedInProfileActivityPage,
+  type LinkedInProfileActivityTarget,
+} from "./linkedin-web-feed";
+
+export function linkedInProfileActivityReadProgram(
+  target: LinkedInProfileActivityTarget,
+  start: number,
+  limit: number,
+): Effect.Effect<WebSessionExecution, ReadEffectFailure, LinkedInProfileActivityPlatform> {
+  return Effect.gen(function*() {
+    const platform = yield* LinkedInProfileActivityPlatform;
+    let stage: LinkedInProfileActivityStage = "identity";
+    let closeFailed = false;
+    return yield* withReadResource(
+      platform.openBrowser,
+      browser => Effect.gen(function*() {
+        const identity = yield* platform.identity(browser);
+        yield* platform.bindIdentity(identity);
+        stage = "binding";
+        const binding = yield* platform.binding(browser, target.slug);
+        stage = "page";
+        const response = yield* platform.page(browser, limit, start);
+        stage = "projection";
+        const observedAt = yield* platform.observedAt;
+        const output = yield* readAttempt(() => projectLinkedInProfileActivityPage({
+          response,
+          target,
+          profileUrn: binding.profileUrn,
+          queryId: binding.queryId,
+          limit,
+          start,
+          observedAt,
+        }));
+        return {
+          status: "succeeded" as const,
+          output,
+          finalUrl: target.activityUrl,
+          dispatchStarted: false,
+          dispatch: { planned: 0, started: 0, verified: 0 },
+        };
+      }),
+      browser => platform.closeBrowser(browser).pipe(Effect.tapError(() => Effect.sync(() => { closeFailed = true; }))),
+    ).pipe(Effect.catchTag("ReadEffectFailure", error => {
+      if (closeFailed || error.cause instanceof PreservedBrowserArtifactsError) return Effect.fail(error);
+      return Effect.succeed({
+        status: "failed" as const,
+        output: null,
+        finalUrl: target.activityUrl,
+        dispatchStarted: false,
+        dispatch: { planned: 0, started: 0, verified: 0 },
+        error: linkedInProfileActivityDiagnostic(error.cause, stage),
+        readFailure: linkedInProfileActivityReadFailure(error.cause, stage),
+      });
+    }));
+  });
+}

package/src/providers/linkedin-read-failure.ts

@@ -0,0 +1,52 @@
+import { OperationDeadlineError } from "../operation-deadline";
+import { readFailureProjection, type ReadFailureProjection } from "../web-session-execution";
+import {
+  WebSessionAuthStateError,
+  WebSessionReadTransportError,
+  WebSessionResponseRejectedError
+} from "../web-session-read-errors";
+import {
+  LinkedInProfileBrowserFailure,
+  LinkedInProfileBrowserResponseRejectedError
+} from "./linkedin-web-profile-browser";
+
+/** Typed provider metadata owns authority/retry decisions. Message text is never
+ * accepted as evidence for a session switch, account mismatch or retry. */
+export function linkedInProfileReadFailure(error: unknown): ReadFailureProjection {
+  let current = error;
+  for (let depth = 0; depth < 8 && current instanceof Error; depth += 1) {
+    if (current instanceof OperationDeadlineError) return readFailureProjection(current.failure === "timed-out" ? "operation-timeout" : "contract-drift");
+    current = current.cause;
+  }
+  current = error;
+  for (let depth = 0; depth < 8 && current instanceof Error; depth += 1) {
+    if (current instanceof LinkedInProfileBrowserResponseRejectedError
+      || current instanceof WebSessionResponseRejectedError) {
+      const status = current.status;
+      return readFailureProjection(status === 401 || status === 403
+        ? "auth-repair-required"
+        : status === 429
+          ? "provider-throttled"
+          : status === 302 || status === 408 || status >= 500 ? "provider-temporary" : "contract-drift");
+    }
+    if (current instanceof WebSessionAuthStateError) return readFailureProjection("auth-repair-required");
+    if (current instanceof WebSessionReadTransportError) return readFailureProjection("provider-temporary");
+    if (current instanceof LinkedInProfileBrowserFailure) return readFailureProjection(current.category === "authwall" || current.category === "session-cookie"
+      ? "auth-repair-required"
+      : current.category === "startup" || current.category === "execution-context"
+        || current.category === "provider-fetch"
+        ? "provider-temporary"
+        : "contract-drift");
+    current = current.cause;
+  }
+  return readFailureProjection("contract-drift");
+}
+
+
+/** Only a rejected native identity response can authorize the reviewed fallback. */
+export function linkedInProfileIdentityAllowsBrowserFallback(cause: unknown): boolean {
+  return cause instanceof WebSessionResponseRejectedError
+    && [302, 401, 403].includes(cause.status)
+    && /^(?:missing|[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+)$/u.test(cause.contentType ?? "missing")
+    && (cause.contentType ?? "missing").length <= 128;
+}

package/src/providers/linkedin-self-platform.ts

@@ -0,0 +1,53 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { ReadEffectFailure, readAttempt } from "../read-effect";
+import type { WebSessionClient } from "../web-session-client";
+import type { LinkedInProfileBrowserTransport } from "./linkedin-web-profile-browser";
+
+export type LinkedInSelfIdentity = {
+  readonly subject: string;
+  readonly publicIdentifier: string | null;
+};
+
+export type LinkedInSelfNative = {
+  readonly openBrowser: () => Promise<LinkedInProfileBrowserTransport>;
+  readonly openDirect: () => Promise<WebSessionClient>;
+  readonly directIdentity: (client: WebSessionClient) => Promise<LinkedInSelfIdentity>;
+  readonly decodeIdentity: (value: unknown) => LinkedInSelfIdentity;
+  readonly bindIdentity: (identity: LinkedInSelfIdentity) => string;
+  readonly readProfile: (client: WebSessionClient, url: string) => Promise<string>;
+  readonly readConnections: (client: WebSessionClient, url: string) => Promise<string>;
+  readonly observedAt: () => string;
+};
+
+const native = <A>(work: () => Promise<A>): Effect.Effect<A, ReadEffectFailure> =>
+  Effect.tryPromise({ try: work, catch: cause => new ReadEffectFailure({ cause }) });
+
+function platform(ports: LinkedInSelfNative) {
+  return {
+    openBrowser: native(ports.openBrowser),
+    closeBrowser: (browser: LinkedInProfileBrowserTransport) => native(() => browser.close()),
+    browserIdentity: (browser: LinkedInProfileBrowserTransport) => native(() => browser.currentIdentityResponse()).pipe(Effect.flatMap(value => readAttempt(() => ports.decodeIdentity(value)))),
+    openDirect: native(ports.openDirect),
+    directIdentity: (client: WebSessionClient) => native(() => ports.directIdentity(client)),
+    bindIdentity: (identity: LinkedInSelfIdentity) => readAttempt(() => ports.bindIdentity(identity)),
+    browserProfile: (
+      browser: LinkedInProfileBrowserTransport,
+      url: string
+
+    ) => native(() => browser.readProfileHtml(url)),
+    browserConnections: (
+      browser: LinkedInProfileBrowserTransport,
+      url: string
+
+    ) => native(() => browser.readConnectionsHtml(url)),
+    directProfile: (client: WebSessionClient, url: string) => native(() => ports.readProfile(client, url)),
+    directConnections: (client: WebSessionClient, url: string) => native(() => ports.readConnections(client, url)),
+    observedAt: readAttempt(ports.observedAt),
+  };
+}
+
+export class LinkedInSelfPlatform extends Context.Tag("wrench/LinkedInSelfPlatform/v1")<LinkedInSelfPlatform, ReturnType<typeof platform>>() { }
+
+export const LinkedInSelfPlatformLive = (ports: LinkedInSelfNative): Layer.Layer<LinkedInSelfPlatform> => Layer.succeed(LinkedInSelfPlatform, platform(ports));

package/src/providers/linkedin-self-program.ts

@@ -0,0 +1,122 @@
+import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
+import { PreservedBrowserArtifactsError } from "../browser";
+import { readAttempt, type ReadEffectFailure, withReadResource } from "../read-effect";
+import {
+  readFailureProjection,
+  type WebSessionExecution
+} from "../web-session-execution";
+import { LinkedInSelfPlatform, type LinkedInSelfIdentity } from "./linkedin-self-platform";
+import { projectLinkedInPersonalProfileStats, type LinkedInProfileTarget } from "./linkedin-web";
+
+import {
+  linkedInProfileIdentityAllowsBrowserFallback,
+  linkedInProfileReadFailure as linkedInSelfReadFailure
+} from "./linkedin-read-failure";
+
+export { linkedInSelfReadFailure };
+
+export function linkedInSelfReadProgram(
+  target: LinkedInProfileTarget,
+  includeConnections: boolean,
+  preferBrowser: boolean,
+  diagnostic: (error: unknown, requestStage: string) => string
+
+): Effect.Effect<WebSessionExecution, ReadEffectFailure, LinkedInSelfPlatform> {
+  return Effect.gen(function*() {
+    const platform = yield* LinkedInSelfPlatform;
+    let requestStage = preferBrowser
+      ? "contained-browser signed-in identity preflight"
+      : "signed-in identity preflight";
+    let identityMismatch = false;
+    const report = (error: ReadEffectFailure): Effect.Effect<WebSessionExecution, ReadEffectFailure> => {
+      if (error.cause instanceof PreservedBrowserArtifactsError) return Effect.fail(error);
+      return Effect.succeed({
+        status: "failed",
+        output: null,
+        finalUrl: target.url,
+        dispatchStarted: false,
+        dispatch: { planned: 0, started: 0, verified: 0 },
+        error: diagnostic(error.cause, requestStage),
+        readFailure: identityMismatch
+          ? readFailureProjection("account-mismatch")
+          : linkedInSelfReadFailure(error.cause)
+      });
+    };
+    const readBoundProfile = (
+      identity: LinkedInSelfIdentity,
+      browser: boolean,
+      profile: Effect.Effect<string, ReadEffectFailure>,
+      connections: Effect.Effect<string, ReadEffectFailure>
+
+    ): Effect.Effect<WebSessionExecution, ReadEffectFailure> => Effect.gen(function*() {
+      const subject = yield* platform.bindIdentity(identity).pipe(Effect.tapError(() => Effect.sync(() => { identityMismatch = true; })));
+      yield* readAttempt(() => {
+        if (identity.publicIdentifier === null) throw new Error("LinkedIn current member omitted its bound public profile identifier");
+        if (identity.publicIdentifier !== target.slug) {
+          identityMismatch = true;
+          throw new Error("LinkedIn current member public profile identifier does not match the requested profile URL");
+        }
+      });
+      requestStage = browser ? "contained-browser public self-profile page read" : "public self-profile page read";
+      const profileHtml = yield* profile;
+      let connectionsHtml: string | null = null;
+      if (includeConnections) {
+        requestStage = browser
+          ? "contained-browser private My Network connections page read"
+          : "private My Network connections page read";
+        connectionsHtml = yield* connections;
+      }
+      requestStage = "exact metric projection";
+      const observedAt = yield* platform.observedAt;
+      const output = yield* readAttempt(() => projectLinkedInPersonalProfileStats({
+        profileHtml,
+        connectionsHtml,
+        profileUrl: target.url,
+        expectedSubject: subject,
+        expectedPublicIdentifier: identity.publicIdentifier,
+        observedAt
+      }));
+      return {
+        status: "succeeded",
+        output,
+        finalUrl: target.url,
+        dispatchStarted: false,
+        dispatch: { planned: 0, started: 0, verified: 0 }
+      };
+    });
+    const browserRead = (): Effect.Effect<WebSessionExecution, ReadEffectFailure> => {
+      let closeFailed = false;
+      return withReadResource(
+        platform.openBrowser,
+        browser => platform.browserIdentity(browser).pipe(Effect.flatMap(identity => readBoundProfile(
+          identity,
+          true,
+          platform.browserProfile(browser, target.url),
+          platform.browserConnections(browser, target.url)
+        ))),
+        browser => platform.closeBrowser(browser).pipe(Effect.tapError(() => Effect.sync(() => { closeFailed = true; }))),
+      ).pipe(Effect.catchTag("ReadEffectFailure", error => closeFailed ? Effect.fail(error) : report(error)));
+    };
+    if (preferBrowser) return yield* browserRead();
+    // A native close rejection must escape the safe read projection just as the
+    // previous finally block did. Only acquisition/operation errors are mapped.
+    const direct = yield* Effect.either(platform.openDirect);
+    if (Either.isLeft(direct)) return yield* report(direct.left);
+    const identity = yield* Effect.either(platform.directIdentity(direct.right));
+    if (Either.isLeft(identity)) {
+      const cause = identity.left.cause;
+      if (linkedInProfileIdentityAllowsBrowserFallback(cause)) {
+        requestStage = "contained-browser signed-in identity preflight";
+        return yield* browserRead();
+      }
+      return yield* report(identity.left);
+    }
+    return yield* readBoundProfile(
+      identity.right,
+      false,
+      platform.directProfile(direct.right, target.url),
+      platform.directConnections(direct.right, target.url)
+    ).pipe(Effect.catchTag("ReadEffectFailure", report));
+  });
+}