@koda-sl/baker-cli 0.471.0 → 0.472.0-dev.607524e67

package/dist/chunk-NHFX7CBM.js

@@ -0,0 +1,175 @@
+import {
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson
+} from "./chunk-G3TL63X5.js";
+import {
+  LINKEDIN_SEARCH_STATUSES,
+  unsupportedLinkedinSearchStatuses
+} from "./chunk-RPJYEJDQ.js";
+import {
+  ApiError
+} from "./chunk-AGIX3HNF.js";
+import {
+  MissingChatIdError,
+  getEnv
+} from "./chunk-PBI5PQEZ.js";
+
+// src/commands/ads/linkedin/shared.ts
+var DAY_MS = 864e5;
+function handleLinkedinError(err) {
+  if (err instanceof ApiError) {
+    if (needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("linkedin_ads", err.message);
+    }
+    if (isNoAccountsSelectedError(err.code, err.message)) {
+      handleConnectionError("linkedin_ads", err.message);
+    }
+    const explanation = explainLinkedinError(err);
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: explanation.action,
+          explanation: explanation.message,
+          correctedCommand: explanation.correctedCommand
+        },
+        retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE" || err.code === "INTERNAL_ERROR"
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  writeAdsJson(unexpectedErrorEnvelope(err));
+  process.exit(1);
+}
+function unexpectedErrorEnvelope(err) {
+  if (err instanceof MissingChatIdError) {
+    return {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: "reject",
+          explanation: "LinkedIn changes are staged in a chat and this run has none. Don't retry: carry on with the rest of the job and tell the user this change couldn't be staged from here."
+        },
+        retryable: false
+      }
+    };
+  }
+  const message = err instanceof Error ? err.message : "Unexpected error";
+  return { ok: false, error: { code: "NETWORK_ERROR", message } };
+}
+function isNoAccountsSelectedError(code, message) {
+  return code === "VALIDATION_ERROR" && /no linkedin ad accounts selected/i.test(message);
+}
+function explainLinkedinError(err) {
+  const lower = err.message.toLowerCase();
+  if (err.code === "VALIDATION_ERROR" && lower.includes("granularity") && lower.includes("daily")) {
+    return {
+      action: "retry_with_flag",
+      message: "LinkedIn rejects DAILY granularity when pivoting on demographic dims (job-title, company, etc.). Re-run with --granularity ALL or MONTHLY.",
+      correctedCommand: void 0
+    };
+  }
+  if (err.code === "RATE_LIMITED") {
+    return {
+      action: "wait_and_retry",
+      message: "Hit a LinkedIn throttle. The CLI already backs off automatically \u2014 if you see this you've exhausted the retry budget. Wait ~60s and retry."
+    };
+  }
+  if (err.code === "INTERNAL_ERROR" && lower.includes("deprecat")) {
+    return {
+      action: "reject",
+      message: "LinkedIn-Version header is deprecated. The backend constant LINKEDIN_API_VERSION needs to be bumped \u2014 file an issue or update the constant."
+    };
+  }
+  return { action: "reject", message: err.message };
+}
+var LI_ACCOUNT_ID_RE = /^(urn:li:sponsoredAccount:)?\d+$/;
+function resolveAccountIdArg(args) {
+  const fromArgs = args["account-id"] ?? args["account-urn"];
+  const id = fromArgs || getEnv().BAKER_LINKEDIN_AD_ACCOUNT_ID;
+  if (!id) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MISSING_ACCOUNT_ID",
+        message: "Pass --account-id (numeric) or --account-urn (urn:li:sponsoredAccount:N), or set BAKER_LINKEDIN_AD_ACCOUNT_ID. Run `baker ads linkedin accounts` to find IDs."
+      }
+    });
+    process.exit(1);
+  }
+  if (!LI_ACCOUNT_ID_RE.test(id)) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: `Invalid LinkedIn account ID "${id}". Expected numeric or urn:li:sponsoredAccount:N.`
+      }
+    });
+    process.exit(1);
+  }
+  return id.startsWith("urn:") ? id.split(":").pop() ?? id : id;
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function daysAgoIso(days) {
+  return new Date(Date.now() - days * DAY_MS).toISOString().slice(0, 10);
+}
+function csvOrJson(args) {
+  return args.output ?? "json";
+}
+function statusesArgDescription(level) {
+  return `CSV of statuses (${LINKEDIN_SEARCH_STATUSES[level].join(",")})`;
+}
+function statusFilterError(level, statuses) {
+  const unsupported = unsupportedLinkedinSearchStatuses(level, statuses);
+  if (unsupported.length === 0) {
+    return null;
+  }
+  const accepted = LINKEDIN_SEARCH_STATUSES[level].join(",");
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_STATUS",
+      message: `LinkedIn does not accept status ${unsupported.join(", ")} for this listing.`,
+      fix: {
+        action: "retry_with_flag",
+        explanation: `Re-run with --statuses from ${accepted}, or --all-statuses to drop the filter.`
+      },
+      retryable: false
+    }
+  };
+}
+function resolveStatusFilter(args, level) {
+  if (args["all-statuses"]) {
+    return void 0;
+  }
+  const explicit = args.statuses;
+  if (!explicit) {
+    return ["ACTIVE"];
+  }
+  const statuses = explicit.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+  const error = statusFilterError(level, statuses);
+  if (error) {
+    writeAdsJson(error);
+    process.exit(1);
+  }
+  return statuses;
+}
+
+export {
+  handleLinkedinError,
+  resolveAccountIdArg,
+  todayIso,
+  daysAgoIso,
+  csvOrJson,
+  statusesArgDescription,
+  resolveStatusFilter
+};
+//# sourceMappingURL=chunk-NHFX7CBM.js.map

package/dist/chunk-NIOO352E.js

@@ -0,0 +1,111 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-Y6ER23FQ.js";
+import {
+  apiGet
+} from "./chunk-AGIX3HNF.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-MV3PVKTU.js";
+
+// src/commands/winning-ads/launches.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.launches",
+  description: 'What the brands you follow (or the ones named) launched in the last N days and which of those ads still run, each with its stage (new, testing, killed_early\u2026), and the tests each brand decided in that window (the version kept, what differed). The "what did competitors launch last week" report. Compact by default; --full lists every launch.',
+  args: {
+    since: { type: "number", description: "Days to look back, 1-90 (default 7)", required: false, default: 7 },
+    advertiser: {
+      type: "string",
+      description: "Comma list of advertiser ids instead of every followed brand",
+      required: false
+    },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  }
+});
+var COMPACT_LAUNCHES = 10;
+function compactLaunches(report, full) {
+  return {
+    since_days: report.since_days,
+    advertisers: report.advertisers.map((b) => ({
+      advertiser_id: b.advertiser_id,
+      label: b.label,
+      launched: b.launched,
+      still_running: b.still_running,
+      launches: (full ? b.launches : b.launches.slice(0, COMPACT_LAUNCHES)).map((l) => ({
+        ad_id: l.ad_id,
+        platform: l.platform,
+        format: l.format,
+        headline: l.headline,
+        first_seen_at: l.first_seen_at,
+        stage: l.stage,
+        idea: l.idea ?? null,
+        ...full ? { media_url: l.media_url } : {}
+      })),
+      tests_decided: (b.tests_decided ?? []).map((t) => ({
+        concept: t.concept,
+        versions: t.versions,
+        kept_ad_id: t.winner_ad_id,
+        decided_at: t.decided_at ?? null,
+        what_differed: t.what_differed
+      }))
+    }))
+  };
+}
+var IDEA_HINT = "Idea: whether each launch was a `new` idea (the first day of its concept), another version of one the brand was still `testing`, or a version built on a `winner` it had already kept. Many launches and no new idea means the brand is iterating on what works, not testing new directions: say so.";
+function launchesHints(report, named) {
+  if (!named && report.following_count === 0) {
+    return ["You follow no brands yet: `baker winning-ads follow <domain>` adds one, or pass --advertiser <id>."];
+  }
+  if (report.advertisers.length === 0) {
+    return [`No launches in the last ${report.since_days} days. Widen the window with --since 30.`];
+  }
+  const withIdeas = report.advertisers.some((b) => b.launches.some((l) => l.idea));
+  return [
+    ...withIdeas ? [IDEA_HINT] : [],
+    "Stages: new \u22647 days, testing \u226421 days, proven \u226460 days, evergreen beyond, killed_early = stopped within 2 weeks (a lost test). tests_decided is what each brand learned in the window: the version it kept (kept_ad_id) and what differed. `baker winning-ads search --survived-test` finds the versions brands kept across the library."
+  ];
+}
+var launchesCommand = defineCommand({
+  meta: {
+    name: "launches",
+    description: "What competitors launched lately and what still runs. Start here: baker winning-ads launches --since 7 (every followed brand), or --advertiser adv_1,adv_2"
+  },
+  args: {
+    since: { type: "string", description: "Days to look back, 1-90 (default 7)", required: false },
+    advertiser: { type: "string", description: "Comma list of advertiser ids", required: false },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const named = splitList(args.advertiser);
+      const params = { since_days: String(args.since ?? 7) };
+      if (named.length > 0) {
+        params.advertiser = named.join(",");
+      }
+      if (args.platform) {
+        params.platform = String(args.platform);
+      }
+      const report = await apiGet("/api/ad-library/launches", params);
+      writeJson({
+        ok: true,
+        data: compactLaunches(report, Boolean(args.full)),
+        hints: launchesHints(report, named.length > 0)
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+
+export {
+  compactLaunches,
+  IDEA_HINT,
+  launchesHints,
+  launchesCommand
+};
+//# sourceMappingURL=chunk-NIOO352E.js.map

package/dist/chunk-NN4UDCIH.js

@@ -0,0 +1,139 @@
+import {
+  brandVerificationHints
+} from "./chunk-IVIJJXXT.js";
+import {
+  OUTPUT_ARGS,
+  writeProviderHits
+} from "./chunk-3TQVRFQN.js";
+import {
+  emptyResultHints
+} from "./chunk-Q6ULQMWG.js";
+import {
+  AUTO_INGEST_MAX,
+  parseAutoIngest
+} from "./chunk-KKJ4KJCW.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-AGIX3HNF.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-MV3PVKTU.js";
+
+// src/commands/images/logo.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.logo",
+  description: "Brand logo lookup via Brandfetch. Auto-ingests by default. Returns `brandMatch` \u2014 Brandfetch's own verdict on whose brand the domain is (confirmed | mismatch | unverified). Branch on it: `mismatch` means the mark is another company's, so do not place it. `confirmed` verifies the record, not the artwork \u2014 read the ingested row back to check the mark itself.",
+  args: {
+    domain: { type: "string", description: "Brand domain (e.g. stripe.com)", required: true },
+    variant: { type: "string", description: "icon | logo | symbol", required: false },
+    "auto-ingest": {
+      type: "number",
+      description: `Ingest top N hits (0-${AUTO_INGEST_MAX.logo}). Defaults to 1 (the first variant). Brandfetch resolves at most ${AUTO_INGEST_MAX.logo} variants, so ${AUTO_INGEST_MAX.logo} ingests every one. Keep it at 1+ \u2014 the ingested row is the only way to check the mark is the brand you asked for.`,
+      required: false
+    },
+    "no-auto-ingest": {
+      type: "boolean",
+      description: "Skip auto-ingest (equivalent to --auto-ingest 0). Leaves the returned mark unverifiable.",
+      required: false,
+      default: false
+    },
+    context: {
+      type: "string",
+      description: "Free-text hint applied to ingested logo variants (e.g. 'Stripe \u2014 payments integration partner', 'Acme competitor brand mark')",
+      required: false
+    },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  }
+});
+var logoCommand = defineCommand({
+  meta: {
+    name: "logo",
+    description: "Brand logo via Brandfetch. Returns up to 5 variants (icon, light/dark logo, light/dark symbol) plus `brandMatch`. Auto-ingests the first variant.\n\nStart here: check `brandMatch.verdict`.\n  mismatch   \u2192 the mark belongs to `brandMatch.name`, a different company. Do not place it.\n  unverified \u2192 nothing confirmed whose logo this is. Treat as unchecked.\n  confirmed  \u2192 Brandfetch has this brand's record. That verifies the record, NOT the artwork \u2014 a confirmed domain has served another company's logo before.\n\n\u26A0 Whatever the verdict, read the ingested row back with `baker images get <imageId>` and check `textInImage`/`subject` before placing it. That is the only check that looks at the mark.\n\nExample: baker images logo stripe.com --variant logo"
+  },
+  args: {
+    domain: { type: "positional", description: "Brand domain", required: false },
+    variant: { type: "string", description: "icon|logo|symbol", required: false },
+    "auto-ingest": {
+      type: "string",
+      description: `Ingest top N (0-${AUTO_INGEST_MAX.logo}, default 1)`,
+      required: false
+    },
+    "no-auto-ingest": { type: "boolean", description: "Skip auto-ingest", required: false },
+    context: { type: "string", description: "Description context hint applied to ingested logos", required: false },
+    ...OUTPUT_ARGS
+  },
+  run: async ({ args }) => {
+    try {
+      const domain = args.domain;
+      if (!domain) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Domain is required" } });
+        process.exit(1);
+      }
+      const body = { domain };
+      if (args.variant) body.variant = args.variant;
+      if (args["auto-ingest"] !== void 0) {
+        const parsed = parseAutoIngest(args["auto-ingest"], AUTO_INGEST_MAX.logo);
+        if (!parsed.ok) {
+          writeJson({
+            ok: false,
+            error: {
+              code: "VALIDATION_ERROR",
+              message: parsed.message,
+              fix: {
+                action: "retry_with_changes",
+                explanation: `Brandfetch resolves at most ${AUTO_INGEST_MAX.logo} variants for a domain, so --auto-ingest ${AUTO_INGEST_MAX.logo} already ingests every one. Re-run with a value in 0-${AUTO_INGEST_MAX.logo}.`
+              }
+            }
+          });
+          process.exit(1);
+        }
+        body.autoIngest = parsed.value;
+      } else if (args["no-auto-ingest"]) {
+        body.autoIngest = 0;
+      }
+      if (args.context) body.descriptionContext = args.context;
+      const data = await apiPost("/api/images/logo", body);
+      const hints = [
+        // `brandMatch` is Brandfetch's own answer to whose brand this domain is,
+        // so the warning can now be graded instead of fired blind: loud on a
+        // mismatch, honest about what a confirmation does and does not cover.
+        ...brandVerificationHints({
+          domain,
+          ingested: data.ingested,
+          hitCount: data.hits.length,
+          brandMatch: data.brandMatch
+        }),
+        ...emptyResultHints({ provider: "logo", hitCount: data.hits.length, activeFilters: [], subject: domain })
+      ];
+      writeProviderHits(data, data.hits, args, hints);
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson({ ok: false, error: { code: err.code, message: err.message } });
+        process.exit(1);
+      }
+      writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+async function fetchBrandLogo(domain) {
+  try {
+    const body = { domain, variant: "logo" };
+    const data = await apiPost("/api/images/logo", body);
+    if (data?.brandMatch?.verdict === "mismatch") return null;
+    return data?.ingested?.[0]?.imageUrl ?? data?.hits?.find((h) => h.imageUrl)?.imageUrl ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  logoCommand,
+  fetchBrandLogo
+};
+//# sourceMappingURL=chunk-NN4UDCIH.js.map