@koda-sl/baker-cli 0.551.0 → 0.554.0

package/dist/chunk-G4JTXVLA.js

@@ -0,0 +1,74 @@
+import {
+  cacheGet,
+  cacheSet,
+  handleConnectionError,
+  needsConnectionFix,
+  writeJsonEnvelope
+} from "./chunk-QYH2UZAK.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-GFWWHCBF.js";
+import {
+  getEnv
+} from "./chunk-45D6WRCJ.js";
+
+// src/commands/ga4/resolve.ts
+async function fetchProperties(useCache = true) {
+  if (useCache) {
+    const cached = cacheGet("ga4-properties", "list");
+    if (cached) return cached.data;
+  }
+  const params = !useCache ? { "skip-cache": "true" } : void 0;
+  const data = await apiGet("/api/ga4/properties", params);
+  if (useCache) {
+    cacheSet("ga4-properties", "list", data, 60 * 60 * 1e3);
+  }
+  return data;
+}
+async function resolvePropertyId(args) {
+  const fromArgs = args["property-id"];
+  const fromEnv = getEnv().BAKER_GA4_PROPERTY_ID;
+  const propertyId = fromArgs || fromEnv;
+  if (propertyId) return propertyId;
+  const useCache = !args["no-cache"];
+  try {
+    const properties = await fetchProperties(useCache);
+    const [single] = properties;
+    if (properties.length === 1 && single) {
+      process.stderr.write(`Using property "${single.name}" (${single.externalId})
+`);
+      return single.externalId;
+    }
+    if (properties.length === 0) {
+      handleConnectionError("ga4");
+    }
+    const list = properties.map((p) => `  ${p.externalId}  ${p.name}`).join("\n");
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: "MULTIPLE_PROPERTIES",
+        message: `Multiple properties found. Pass --property-id or set BAKER_GA4_PROPERTY_ID:
+${list}`
+      }
+    });
+    process.exit(1);
+  } catch (err) {
+    if (err instanceof ApiError && needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("ga4", err.message);
+    }
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: "RESOLUTION_ERROR",
+        message: "Could not auto-detect property. Pass --property-id or set BAKER_GA4_PROPERTY_ID."
+      }
+    });
+    process.exit(1);
+  }
+}
+
+export {
+  resolvePropertyId
+};
+//# sourceMappingURL=chunk-G4JTXVLA.js.map

package/dist/chunk-G6U45QD3.js

@@ -0,0 +1,296 @@
+import {
+  DIRECT_ROUTE,
+  captureProxyCredentials,
+  childEnvWith,
+  plannedRoutes,
+  shouldEscalate
+} from "./chunk-45D6WRCJ.js";
+
+// src/lib/vimeoCookie.ts
+import { writeFile } from "fs/promises";
+import path from "path";
+var COOKIE_NAME = "vimeo";
+async function writeVimeoCookieFile(cookie, workDir) {
+  const value = cookie?.trim();
+  if (!value) return void 0;
+  const expires = Math.floor(Date.now() / 1e3) + 365 * 24 * 60 * 60;
+  const jar = [
+    "# Netscape HTTP Cookie File",
+    [".vimeo.com", "TRUE", "/", "TRUE", String(expires), COOKIE_NAME, value].join("	"),
+    ""
+  ].join("\n");
+  const filePath = path.join(workDir, "vimeo-cookies.txt");
+  await writeFile(filePath, jar, { mode: 384 });
+  return filePath;
+}
+var VIMEO_AUTH_SIGNATURES = ["oauth token", "only works when logged-in", "unable to fetch new oauth tokens"];
+function isVimeoAuthFailure(detail) {
+  const haystack = detail.toLowerCase();
+  if (!haystack.includes("[vimeo]")) return false;
+  return VIMEO_AUTH_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+
+// src/lib/ytDlpSignal.ts
+var HTTP_ERROR = /HTTP Error (\d{3})/i;
+var CHALLENGE_PHRASES = [
+  "sign in to confirm you're not a bot",
+  "sign in to confirm you\u2019re not a bot",
+  "confirm you are not a bot",
+  "unusual traffic",
+  "captcha"
+];
+var NOT_A_BLOCK_PHRASES = ["private video", "video unavailable", "members-only", "this video is available to"];
+var PROXY_TUNNEL_FAILURE = /tunnel connection failed: 407|proxy authentication required|http error 407/i;
+function ytDlpBlockSignal(stderr) {
+  const text = stderr.toLowerCase();
+  if (PROXY_TUNNEL_FAILURE.test(stderr)) return { status: 407 };
+  if (NOT_A_BLOCK_PHRASES.some((phrase) => text.includes(phrase))) return {};
+  const status = HTTP_ERROR.exec(stderr);
+  if (status) return { status: Number(status[1]) };
+  if (CHALLENGE_PHRASES.some((phrase) => text.includes(phrase))) return { challenge: true };
+  return {};
+}
+
+// src/lib/ytDlp.ts
+import { spawn } from "child_process";
+import { readdir, readFile } from "fs/promises";
+import path2 from "path";
+
+// src/lib/ytDlpFormat.ts
+function videoFormatArgs(maxResolution) {
+  const sort = maxResolution ? ["-S", `res:${maxResolution}`] : [];
+  return ["--format", "bv*+ba/b", ...sort, "--merge-output-format", "mp4"];
+}
+
+// src/lib/ytDlpPlayerClient.ts
+var YOUTUBE_FALLBACK_CLIENT_ARGS = ["--extractor-args", "youtube:player_client=android"];
+var MEDIA_FETCH_REFUSED = "unable to download video data";
+var YOUTUBE_HOSTS = ["youtube.com", "youtu.be"];
+function isYouTube(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return YOUTUBE_HOSTS.some((known) => host === known || host.endsWith(`.${known}`));
+}
+function needsPlayerClientRetry(url, stderr) {
+  return isYouTube(url) && stderr.toLowerCase().includes(MEDIA_FETCH_REFUSED);
+}
+
+// src/lib/ytDlp.ts
+var YT_DLP_BIN = "yt-dlp";
+var YT_DLP_TIMEOUT_MS = 10 * 60 * 1e3;
+var YT_DLP_PROBE_TIMEOUT_MS = 60 * 1e3;
+var TRUST_SYSTEM_CERTS = ["--compat-options", "no-certifi"];
+var YtDlpError = class extends Error {
+  constructor(message, stderrTail) {
+    super(message);
+    this.stderrTail = stderrTail;
+    this.name = "YtDlpError";
+  }
+};
+function tail(text, maxLines) {
+  return text.split("\n").slice(-maxLines).join("\n");
+}
+async function runYtDlp(args) {
+  const outTemplate = path2.join(args.workDir, "out.%(ext)s");
+  const infoPath = path2.join(args.workDir, "out.info.json");
+  const argv = [
+    args.url,
+    "--no-playlist",
+    "--no-progress",
+    "--no-warnings",
+    "--quiet",
+    "--write-info-json",
+    ...TRUST_SYSTEM_CERTS,
+    "-o",
+    outTemplate
+  ];
+  if (args.audioOnly) {
+    argv.push("-x", "--audio-format", "m4a");
+  } else {
+    argv.push(...videoFormatArgs(args.maxHeight));
+  }
+  const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.workDir);
+  if (cookieFile) argv.push("--cookies", cookieFile);
+  args.onLog?.(`yt-dlp: downloading ${args.audioOnly ? "audio" : "video"}`);
+  const timeoutMs = args.timeoutMs ?? YT_DLP_TIMEOUT_MS;
+  const { code, stderr, tier, reducedQuality } = await downloadWithClientFallback({
+    url: args.url,
+    argv,
+    onLog: args.onLog,
+    ladder: (attemptArgv) => runViaLadder({ url: args.url, argv: attemptArgv, timeoutMs, onLog: args.onLog, country: args.country }),
+    repeat: (attemptArgv, route) => spawnAndWait(YT_DLP_BIN, attemptArgv, timeoutMs, { extraEnv: proxyEnvFor(route) })
+  });
+  if (code !== 0) {
+    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));
+  }
+  const files = await readdir(args.workDir);
+  const wanted = args.audioOnly ? ".m4a" : ".mp4";
+  const downloaded = files.find((f) => f.startsWith("out.") && f.endsWith(wanted));
+  if (!downloaded) {
+    throw new YtDlpError(`yt-dlp finished but produced no ${wanted} file (saw: ${files.join(", ")})`, "");
+  }
+  let info = {};
+  try {
+    info = JSON.parse(await readFile(infoPath, "utf-8"));
+  } catch {
+  }
+  return { filePath: path2.join(args.workDir, downloaded), info, tier, reducedQuality };
+}
+async function probeYtDlp(args) {
+  const argv = [
+    args.url,
+    "--no-playlist",
+    "--no-warnings",
+    "--dump-single-json",
+    "--skip-download",
+    // Without this the probe fails wherever the *download* would fail, which
+    // defeats the point of probing: yt-dlp still runs format selection for
+    // `--dump-single-json`, so a binary too old to read a site's format list
+    // exits "Requested format is not available" and we learn nothing — measured
+    // against a stale build, which returned full metadata the moment this flag
+    // was added. Duration and id come from the page, not from a format.
+    "--ignore-no-formats-error",
+    ...TRUST_SYSTEM_CERTS
+  ];
+  if (args.cookieDir) {
+    const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.cookieDir);
+    if (cookieFile) argv.push("--cookies", cookieFile);
+  }
+  let stdout = "";
+  const { code, stderr, tier } = await walkYtDlpLadder({
+    url: args.url,
+    credentials: captureProxyCredentials(),
+    attempt: async (route) => {
+      const result = await spawnAndWait(YT_DLP_BIN, argv, args.timeoutMs ?? YT_DLP_PROBE_TIMEOUT_MS, {
+        extraEnv: proxyEnvFor(route),
+        captureStdout: true
+      });
+      stdout = result.stdout ?? "";
+      return result;
+    },
+    onLog: args.onLog,
+    country: args.country
+  });
+  if (code !== 0) {
+    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new YtDlpError("yt-dlp returned metadata that could not be read", tail(stdout, 5));
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    throw new YtDlpError("yt-dlp returned no metadata for that link", tail(stderr, 40));
+  }
+  return { info: parsed, tier };
+}
+function isAudioOnly(info) {
+  return info.vcodec === "none";
+}
+function durationSeconds(info) {
+  const raw = info.duration;
+  return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : void 0;
+}
+function canonicalUrl(info) {
+  const raw = info.webpage_url;
+  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+async function walkYtDlpLadder(args) {
+  const routes = plannedRoutes(args.url, args.credentials, args.country ? { country: args.country } : void 0);
+  let last = { code: -1, stderr: "", tier: "direct", route: DIRECT_ROUTE };
+  for (const route of routes) {
+    const tier = route.kind === "proxy" ? route.tier : "direct";
+    if (route.kind === "proxy") args.onLog?.(`yt-dlp: retrying via ${tier}`);
+    last = { ...await args.attempt(route), tier, route };
+    if (last.code === 0) return last;
+    if (!shouldEscalate(ytDlpBlockSignal(last.stderr))) return last;
+  }
+  return last;
+}
+async function downloadWithClientFallback(args) {
+  const first = await args.ladder(args.argv);
+  if (first.code === 0 || !needsPlayerClientRetry(args.url, first.stderr)) {
+    return { ...first, reducedQuality: false };
+  }
+  args.onLog?.("yt-dlp: retrying with the fallback player client");
+  const again = await args.repeat([...args.argv, ...YOUTUBE_FALLBACK_CLIENT_ARGS], first.route);
+  return { ...again, tier: first.tier, route: first.route, reducedQuality: again.code === 0 };
+}
+function runViaLadder(args) {
+  return walkYtDlpLadder({
+    url: args.url,
+    credentials: captureProxyCredentials(),
+    attempt: (route) => spawnAndWait(YT_DLP_BIN, args.argv, args.timeoutMs, { extraEnv: proxyEnvFor(route) }),
+    onLog: args.onLog,
+    country: args.country
+  });
+}
+function proxyEnvFor(route) {
+  if (route.kind !== "proxy") return void 0;
+  const uri = new URL(route.server);
+  uri.username = encodeURIComponent(route.username);
+  uri.password = encodeURIComponent(route.password);
+  return {
+    HTTP_PROXY: uri.toString(),
+    HTTPS_PROXY: uri.toString(),
+    http_proxy: uri.toString(),
+    https_proxy: uri.toString()
+  };
+}
+function spawnAndWait(bin, argv, timeoutMs, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, argv, {
+      stdio: ["ignore", "pipe", "pipe"],
+      // `childEnvWith` because `spawn`'s `env` REPLACES the environment rather
+      // than extending it — passing only the additions would strip PATH.
+      ...options.extraEnv ? { env: childEnvWith(options.extraEnv) } : {}
+    });
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    let stderrLen = 0;
+    const MAX_STDERR = 256 * 1024;
+    child.stdout.on("data", (chunk) => {
+      if (options.captureStdout) stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderrLen < MAX_STDERR) {
+        stderrChunks.push(chunk);
+        stderrLen += chunk.length;
+      }
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${bin} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`failed to spawn "${bin}" \u2014 ${err.message}`));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        code: code ?? -1,
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        ...options.captureStdout ? { stdout: Buffer.concat(stdoutChunks).toString("utf-8") } : {}
+      });
+    });
+  });
+}
+
+export {
+  isVimeoAuthFailure,
+  ytDlpBlockSignal,
+  YT_DLP_BIN,
+  YtDlpError,
+  runYtDlp,
+  probeYtDlp,
+  isAudioOnly,
+  durationSeconds,
+  canonicalUrl
+};
+//# sourceMappingURL=chunk-G6U45QD3.js.map

package/dist/chunk-GAP7SOGA.js

@@ -0,0 +1,188 @@
+import {
+  analyticsErrorEnvelope
+} from "./chunk-5HPKYRTE.js";
+import {
+  PEOPLE_SEARCH_MAX_TERMS,
+  parsePeopleQuery,
+  peopleLookupRequestSchema
+} from "./chunk-PILLZPNC.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-QYH2UZAK.js";
+import {
+  apiPost
+} from "./chunk-GFWWHCBF.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+
+// src/commands/analytics/lookup.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+function peopleArgs(args2) {
+  const parts = peopleParts(args2);
+  if (parts.length === 0) return {};
+  const people = parsePeopleQuery(parts).terms.map((term) => term.input);
+  return people.length === 0 ? {} : { people };
+}
+function peopleParts(args2) {
+  return [...args2.person ? [String(args2.person)] : [], ...args2["people-file"] ? [readPeopleFile(args2)] : []];
+}
+function readPeopleFile(args2) {
+  try {
+    return readFileSync(String(args2["people-file"]), "utf8");
+  } catch {
+    return "";
+  }
+}
+function unreadablePeopleFile(args2) {
+  if (!args2["people-file"]) return void 0;
+  const path = String(args2["people-file"]);
+  try {
+    readFileSync(path, "utf8");
+    return void 0;
+  } catch {
+    return `Couldn't read --people-file ${path}. Check the path, or pass the people inline with --person.`;
+  }
+}
+function peopleLimitError(args2) {
+  const unreadable = unreadablePeopleFile(args2);
+  if (unreadable !== void 0) return unreadable;
+  const { terms, dropped } = parsePeopleQuery(peopleParts(args2));
+  if (dropped === 0) return void 0;
+  return `${terms.length + dropped} people named; one search takes up to ${PEOPLE_SEARCH_MAX_TERMS}. Split the list and run each part.`;
+}
+function compactRow(row) {
+  const clicks = [...row.googleClick ? ["google"] : [], ...row.metaClick ? ["meta"] : []];
+  const candidates = {
+    input: row.input,
+    readAs: row.kind,
+    found: row.found,
+    problem: row.problem,
+    contacts: row.contacts,
+    events: row.events,
+    firstSeen: row.firstSeen,
+    lastSeen: row.lastSeen,
+    pageViews: row.pageViews,
+    landings: row.landings,
+    visits: row.visits,
+    formSubmits: row.formSubmits,
+    firstSource: row.firstSource,
+    systemEvents: row.systemEvents,
+    pageEvents: row.pageEvents,
+    uploads: row.uploads,
+    uploadedTo: row.uploadedTo,
+    clicks,
+    knownBy: row.knownBy
+  };
+  return Object.fromEntries(
+    Object.entries(candidates).filter(
+      ([key, value]) => key === "found" || !(value === 0 || value === "" || Array.isArray(value) && value.length === 0)
+    )
+  );
+}
+function lookupHints(data) {
+  const hints = [];
+  if (data.dropped > 0) {
+    hints.push(
+      `${data.dropped} lines past the limit of ${PEOPLE_SEARCH_MAX_TERMS} were not looked up. Run the rest separately.`
+    );
+  }
+  const unseen = data.people.filter((row) => !row.found && row.problem === "");
+  if (unseen.length > 0) {
+    hints.push(
+      `Not seen by Baker: ${unseen.map((row) => row.input).join(", ")}. Baker knows a person by what its pages, Forms and connected systems recorded \u2014 a lead that came in through a form or site Baker does not measure, or a source not connected, is not here.`
+    );
+  }
+  for (const row of data.people.filter((person) => person.problem !== "")) {
+    hints.push(`${row.input}: ${row.problem}`);
+  }
+  const found = data.people.filter((row) => row.found);
+  const neverVisited = found.filter((row) => row.pageViews === 0);
+  if (neverVisited.length > 0) {
+    hints.push(
+      `${neverVisited.length} of ${found.length} found never visited a page Baker publishes: Baker knows them only from what their systems reported, so no landing can be credited with them.`
+    );
+  }
+  if (found.length > 0) {
+    hints.push(
+      `\`baker analytics feed --person '${found[0]?.input}' --days 90\` lists everything one of them did, in order \u2014 add more, comma-separated, to follow several.`
+    );
+  }
+  return hints;
+}
+function lookupReport(data, full = false) {
+  const found = data.people.filter((row) => row.found);
+  return {
+    summary: {
+      searched: data.people.length,
+      found: found.length,
+      notFound: data.people.length - found.length,
+      visitedABakerPage: found.filter((row) => row.pageViews > 0).length
+    },
+    people: full ? data.people : data.people.map(compactRow),
+    hints: lookupHints(data)
+  };
+}
+var NO_PEOPLE = "Name at least one person: --person 'ana@empresa.com, deal:40001234567' or --people-file leads.txt.";
+var args = {
+  person: {
+    type: "string",
+    description: "The people, comma-separated: an email, a phone (+34\u2026), a HubSpot contact id, deal:<HubSpot deal id>, a gclid/fbclid, a browser id. Prefix to be exact: email:, phone:, hubspot:, deal:, gclid:, fbclid:, browser:",
+    required: false
+  },
+  "people-file": {
+    type: "string",
+    description: "A file with one person per line \u2014 a column pasted from a CRM export",
+    required: false
+  },
+  full: {
+    type: "boolean",
+    description: "Every field of every line, zeros included",
+    required: false
+  }
+};
+registerSchema({
+  command: "analytics.lookup",
+  description: "What Baker saw of each person in a list, by email, phone, CRM id, deal or click id",
+  args
+});
+var lookupCommand = defineCommand({
+  meta: {
+    name: "lookup",
+    description: `What Baker saw of each person in a list \u2014 all time, one line each \u2014 by whatever the client holds about them. The reconciliation question: "HubSpot says 26 leads yesterday, which of them does Baker have, and where did they come from".
+
+Start here:
+  baker analytics lookup --person 'ana@empresa.com, +34600111222, 90001234567'
+  baker analytics lookup --person 'deal:40001234567, deal:40001234568'   \u2014 HubSpot deal ids, looked up through the deal's contacts
+  baker analytics lookup --people-file leads.txt                           \u2014 one per line, up to ${PEOPLE_SEARCH_MAX_TERMS}
+
+Each line says whether Baker has them, when it first and last saw them, the pages and Forms they touched, what their systems reported (systemEvents: CRM stages, orders), what Baker uploaded for them to ad platforms, which ad click they carried, and every kind of key they are linked by. A bare number is read as a HubSpot contact id or a phone; prefix it to be exact. Emails and phones are hashed by Baker \u2014 say them to the client as they gave them, never as a hash. Follow one with \`baker analytics feed --person <same value>\`.`
+  },
+  args,
+  run: async ({ args: raw }) => {
+    const { people } = peopleArgs(raw);
+    const parsed = peopleLookupRequestSchema.safeParse({ people: people ?? [] });
+    const invalid = peopleLimitError(raw) ?? (parsed.success ? void 0 : NO_PEOPLE);
+    if (invalid !== void 0 || !parsed.success) {
+      writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: invalid ?? NO_PEOPLE } });
+      process.exit(1);
+    }
+    try {
+      const response = await apiPost("/api/analytics/people", parsed.data);
+      const { hints, ...data } = lookupReport(response.data, raw.full === true);
+      writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+    } catch (error) {
+      writeJsonEnvelope({ ok: false, error: analyticsErrorEnvelope(error) });
+      process.exit(1);
+    }
+  }
+});
+
+export {
+  peopleArgs,
+  peopleLimitError,
+  lookupReport,
+  lookupCommand
+};
+//# sourceMappingURL=chunk-GAP7SOGA.js.map