@dench.com/cli 2.1.1 → 2.1.3

package/lib/enrichment-gateway.ts

@@ -1055,12 +1055,13 @@ export async function aviatoEnrichPerson(
   body: AviatoEnrichPersonBody,
   options: EnrichmentGatewayOptions = {},
 ): Promise<Record<string, unknown>> {
+  const linkedinUrl = body.linkedinUrl?.trim();
+  const linkedinID = body.linkedinID?.trim();
+  const linkedinNumID = body.linkedinNumID?.trim();
+  const linkedinEntityId = body.linkedinEntityId?.trim();
+  const email = body.email?.trim();
   const hasIdentifier =
-    body.linkedinUrl ||
-    body.linkedinID ||
-    body.linkedinNumID ||
-    body.linkedinEntityId ||
-    body.email;
+    linkedinUrl || linkedinID || linkedinNumID || linkedinEntityId || email;
   if (!hasIdentifier) {
     throw new EnrichmentGatewayError(
       "Aviato person enrichment requires at least one identifier: linkedinUrl, linkedinID, linkedinNumID, linkedinEntityId, or email.",
@@ -1068,14 +1069,24 @@ export async function aviatoEnrichPerson(
     );
   }
 
+  // Aviato rejects email-only lookups in preview mode ("Email lookups are
+  // not allowed in preview mode"), so when email is the sole identifier we
+  // upgrade to a full (charged) lookup rather than surfacing a hard 400.
+  const emailOnly =
+    Boolean(email) &&
+    !linkedinUrl &&
+    !linkedinID &&
+    !linkedinNumID &&
+    !linkedinEntityId;
+
   const requestBody: Record<string, unknown> = {};
-  if (body.linkedinUrl) requestBody.linkedinURL = body.linkedinUrl.trim();
-  if (body.linkedinID) requestBody.linkedinID = body.linkedinID.trim();
-  if (body.linkedinNumID) requestBody.linkedinNumID = body.linkedinNumID.trim();
-  if (body.linkedinEntityId)
-    requestBody.linkedinEntityId = body.linkedinEntityId.trim();
-  if (body.email) requestBody.email = body.email.trim();
-  if (body.preview !== undefined) requestBody.preview = body.preview;
+  if (linkedinUrl) requestBody.linkedinURL = linkedinUrl;
+  if (linkedinID) requestBody.linkedinID = linkedinID;
+  if (linkedinNumID) requestBody.linkedinNumID = linkedinNumID;
+  if (linkedinEntityId) requestBody.linkedinEntityId = linkedinEntityId;
+  if (email) requestBody.email = email;
+  if (body.preview !== undefined && !(body.preview && emailOnly))
+    requestBody.preview = body.preview;
 
   const raw = await callGatewayJson("/v1/enrichment/aviato/person", {
     method: "POST",

package/lib/organizationSelector.ts

@@ -0,0 +1,58 @@
+type OrganizationSelectorFields = {
+  _id?: string;
+  id?: string;
+  name: string;
+  slug: string;
+};
+
+export function normalizeOrganizationSelector(input: string | undefined | null) {
+  const trimmed = input?.trim();
+  if (!trimmed) return undefined;
+  return trimmed.slice(0, 160);
+}
+
+function organizationId(organization: OrganizationSelectorFields) {
+  return String(organization._id ?? organization.id ?? "");
+}
+
+export function organizationMatchesSelector(
+  organization: OrganizationSelectorFields | null | undefined,
+  selector: string | null | undefined,
+) {
+  const normalizedSelector =
+    normalizeOrganizationSelector(selector)?.toLowerCase();
+  if (!organization || !normalizedSelector) return false;
+  return (
+    organizationId(organization).toLowerCase() === normalizedSelector ||
+    organization.slug.toLowerCase() === normalizedSelector ||
+    organization.name.trim().toLowerCase() === normalizedSelector
+  );
+}
+
+export function resolveOrganizationBySelector<
+  T extends OrganizationSelectorFields,
+>(organizations: T[], selector: string | null | undefined): T | null {
+  const normalizedSelector =
+    normalizeOrganizationSelector(selector)?.toLowerCase();
+  if (!normalizedSelector) return null;
+
+  const slugMatch = organizations.find(
+    (organization) =>
+      organization.slug.toLowerCase() === normalizedSelector,
+  );
+  if (slugMatch) return slugMatch;
+
+  const idMatch = organizations.find(
+    (organization) =>
+      organizationId(organization).toLowerCase() === normalizedSelector,
+  );
+  if (idMatch) return idMatch;
+
+  const nameMatches = organizations.filter(
+    (organization) =>
+      organization.name.trim().toLowerCase() === normalizedSelector,
+  );
+  if (nameMatches.length === 1) return nameMatches[0];
+
+  return null;
+}

package/linkedin.ts

@@ -0,0 +1,210 @@
+/**
+ * `dench linkedin` — first-class LinkedIn outreach workflows.
+ *
+ * This is intentionally not a generic browser surface. The CLI sends
+ * one high-level command to Dench Cloud, where Browserbase + the
+ * LinkedIn-specific verifier do the whole transaction server-side.
+ */
+
+import { hasFlag } from "./lib/cli-args";
+
+type RuntimeBundle = {
+  host: string;
+  bearerToken: string;
+};
+
+type LinkedInCliContext = {
+  args: string[];
+  jsonOutput: boolean;
+  runtime: RuntimeBundle;
+};
+
+type LinkedInResponse = Record<string, unknown> & {
+  crmUpdate?: unknown;
+  currentUrl?: string | null;
+  error?: string;
+  message?: string;
+  ok?: boolean;
+  pageTitle?: string | null;
+  profileUrl?: string;
+  status?: string;
+  threadId?: string;
+  threadUrl?: string;
+  verified?: boolean;
+};
+
+class LinkedInCliError extends Error {}
+
+function linkedinHelp(): void {
+  console.log(`Usage: dench linkedin <subcommand>
+
+Connect with a LinkedIn profile using the cloud Browserbase browser:
+  dench linkedin connect <profileUrl> [--entry people:<entryId>] [--thread <threadId>] [--json]
+
+CRM:
+  --entry people:<entryId>      Update that CRM row after verification.
+  --object <object> --entry-id <entryId>
+                               Same as --entry, split into two flags.
+
+Behavior:
+  CRM is marked reached out only when LinkedIn verifies Pending.
+  If LinkedIn asks for login, rate-limits, or shows an unclear modal,
+  the result is manual_review and the browser thread stays live.
+`);
+}
+
+function consumeFlagValue(args: string[], name: string): string | undefined {
+  const idx = args.indexOf(name);
+  if (idx === -1) return undefined;
+  const value = args[idx + 1];
+  args.splice(idx, 2);
+  return value;
+}
+
+function normalizeProfileUrl(input: string | undefined): string {
+  const value = input?.trim();
+  if (!value) {
+    throw new LinkedInCliError(
+      "Usage: dench linkedin connect <profileUrl> [--entry people:<entryId>]",
+    );
+  }
+  if (/^https?:\/\//i.test(value)) return value;
+  return `https://${value}`;
+}
+
+function parseEntry(value: string | undefined) {
+  if (!value) return null;
+  const [objectName, ...rest] = value.split(":");
+  const entryId = rest.join(":").trim();
+  if (!objectName?.trim() || !entryId) {
+    throw new LinkedInCliError("--entry must look like people:<entryId>");
+  }
+  return { objectName: objectName.trim(), entryId };
+}
+
+function buildLinkedInCliUrl(host: string): string {
+  return `${host.replace(/\/+$/, "")}/api/linkedin/cli`;
+}
+
+async function postJson(
+  url: string,
+  bearer: string,
+  body: unknown,
+): Promise<{ ok: boolean; payload: unknown; status: number }> {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${bearer}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let payload: unknown;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { raw: text };
+  }
+  return { ok: response.ok, payload, status: response.status };
+}
+
+function payloadError(payload: unknown): string {
+  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+    const error = (payload as { error?: unknown }).error;
+    if (typeof error === "string" && error.trim()) return error;
+  }
+  return "LinkedIn request failed";
+}
+
+function output(ctx: LinkedInCliContext, value: unknown): void {
+  if (ctx.jsonOutput) {
+    console.log(JSON.stringify(value, null, 2));
+    return;
+  }
+  console.log(String(value));
+}
+
+function formatHuman(response: LinkedInResponse) {
+  const lines: string[] = [];
+  const status = response.status ?? "unknown";
+  if (response.ok === false) {
+    lines.push(`LinkedIn connect failed: ${response.error ?? status}`);
+  } else {
+    lines.push(`LinkedIn connect: ${status}`);
+  }
+  if (response.verified !== undefined) {
+    lines.push(`verified: ${response.verified ? "yes" : "no"}`);
+  }
+  if (response.message) lines.push(`result: ${response.message}`);
+  if (response.profileUrl) lines.push(`profile: ${response.profileUrl}`);
+  if (response.currentUrl) lines.push(`url: ${response.currentUrl}`);
+  if (response.threadId) lines.push(`threadId: ${response.threadId}`);
+  if (response.crmUpdate) lines.push("crm: updated");
+  if (response.threadUrl) {
+    lines.push("");
+    lines.push(`Open in Dench: ${response.threadUrl}`);
+  }
+  return lines.join("\n");
+}
+
+async function runConnectCommand(ctx: LinkedInCliContext) {
+  const threadId = consumeFlagValue(ctx.args, "--thread");
+  const entry = parseEntry(consumeFlagValue(ctx.args, "--entry"));
+  const objectName =
+    consumeFlagValue(ctx.args, "--object") ?? entry?.objectName;
+  const entryId = consumeFlagValue(ctx.args, "--entry-id") ?? entry?.entryId;
+  const profileUrl = normalizeProfileUrl(ctx.args.shift());
+
+  const body = {
+    action: "connect",
+    profileUrl,
+    threadId,
+    ...(objectName ? { crmObjectName: objectName } : {}),
+    ...(entryId ? { crmEntryId: entryId } : {}),
+  };
+
+  const result = await postJson(
+    buildLinkedInCliUrl(ctx.runtime.host),
+    ctx.runtime.bearerToken,
+    body,
+  );
+  if (!result.ok) {
+    throw new LinkedInCliError(
+      `${payloadError(result.payload)} (${result.status})`,
+    );
+  }
+
+  const response =
+    result.payload && typeof result.payload === "object"
+      ? (result.payload as LinkedInResponse)
+      : ({} as LinkedInResponse);
+
+  output(ctx, ctx.jsonOutput ? response : formatHuman(response));
+}
+
+export async function runLinkedInCommand(opts: {
+  args: string[];
+  runtime: RuntimeBundle;
+}): Promise<void> {
+  const args = [...opts.args];
+  const jsonOutput = hasFlag(args, "--json");
+  const ctx: LinkedInCliContext = {
+    args,
+    jsonOutput,
+    runtime: opts.runtime,
+  };
+  const subcommand = args.shift();
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    linkedinHelp();
+    return;
+  }
+  if (subcommand === "connect") {
+    await runConnectCommand(ctx);
+    return;
+  }
+  throw new LinkedInCliError(`Unknown linkedin subcommand: ${subcommand}`);
+}
+
+export { LinkedInCliError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dench.com/cli",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "Dench agent workspace CLI. v2 unifies auth behind `dench signin`; the legacy `dench login` / `dench onboard` / `dench setup` / `dench what-can-i-do` / `dench register` commands now error with a redirect.",
   "type": "module",
   "bin": {
@@ -26,6 +26,8 @@
     "crm.ts",
     "members.ts",
     "cron.ts",
+    "browser.ts",
+    "linkedin.ts",
     "search.ts",
     "image.ts",
     "tools.ts",
@@ -34,6 +36,7 @@
     "host.ts",
     "openUrl.ts",
     "session.ts",
+    "lib/organizationSelector.ts",
     "lib/",
     "README.md"
   ],
@@ -43,7 +46,8 @@
   "dependencies": {
     "chokidar": "^5.0.0",
     "convex": "1.34.0",
-    "tsx": "^4.21.0"
+    "tsx": "^4.21.0",
+    "zod": "4.3.6"
   },
   "publishConfig": {
     "access": "public"