@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.481.0-dev.2d33e194f

package/dist/chunk-QTL4NJ5I.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/winning-ads/adRows.ts"],"sourcesContent":["import { applyFieldMask, compactWinningAd, fullWinningAd, winningAdNormalizer, writeJson } from \"../../output.ts\";\n\n/**\n * The rows `search`, `feed`, `winners` and `ads` print: one ad each, compact\n * unless `--full`, cut to `--fields` in every output. Before, the JSON a\n * `feed`, `winners` or `ads` call prints ignored `--fields`, so an agent that\n * asked for three columns still read every row whole.\n */\n\nexport type AdFieldPlan = { fields: string[] | undefined; full: boolean };\n\n// A row with every optional signal set: its keys are every field an ad row can carry.\nconst EVERY_SIGNAL: Record<string, unknown> = {\n  dna: {\n    visual: \"-\",\n    container: \"-\",\n    mechanism: \"-\",\n    audience_temperature: \"-\",\n    funnel_stage: \"-\",\n    advertiser_size: \"-\",\n    presumes_brand_knowledge: true,\n    brand_knowledge_reason: \"-\",\n  },\n  baker_uses: { companies: 1, ours: true, approved: 1, rejected: 1 },\n  source: \"followed\",\n  stage: \"-\",\n  survived_test: true,\n};\nconst COMPACT_FIELDS = new Set(Object.keys(compactWinningAd(EVERY_SIGNAL)));\nconst ALL_FIELDS = Object.keys(fullWinningAd(EVERY_SIGNAL));\n\n/**\n * The `--fields` asked for, read the way an agent types them: names trimmed,\n * the full row when a name only `--full` carries is asked for, and a name no\n * row carries refused with the ones that exist. Before, each of those printed\n * an empty column.\n */\nexport function adFields(\n  requested: string[] | undefined,\n  full: boolean,\n): AdFieldPlan | { invalid: string[]; valid: string[] } {\n  if (!requested) return { fields: undefined, full };\n  const fields = requested.map((f) => f.trim()).filter(Boolean);\n  const invalid = fields.filter((f) => !ALL_FIELDS.includes(f));\n  if (invalid.length > 0) return { invalid, valid: ALL_FIELDS };\n  return { fields, full: full || fields.some((f) => !COMPACT_FIELDS.has(f)) };\n}\n\n/** The `--fields` plan of a command, or the refusal of a name no row carries (exits). */\nexport function adFieldPlan(fields: unknown, full: unknown): AdFieldPlan {\n  const plan = adFields(fields ? String(fields).split(\",\") : undefined, Boolean(full));\n  if (!(\"invalid\" in plan)) return plan;\n  writeJson({\n    ok: false,\n    error: {\n      code: \"VALIDATION_ERROR\",\n      message: `Unknown --fields: ${plan.invalid.join(\", \")}`,\n      fix: {\n        action: \"retry_with_valid_values\",\n        explanation: \"Pass only fields an ad row carries.\",\n        flag: \"--fields\",\n        invalidValues: plan.invalid,\n        validValues: plan.valid,\n      },\n    },\n  });\n  process.exit(1);\n}\n\nexport function adRows(raw: readonly unknown[], plan: AdFieldPlan): Record<string, unknown>[] {\n  return raw.map((r) => {\n    const row = winningAdNormalizer(r as Record<string, unknown>, plan.full);\n    return plan.fields ? applyFieldMask(row, plan.fields) : row;\n  });\n}\n"],"mappings":";;;;;;;;;AAYA,IAAM,eAAwC;AAAA,EAC5C,KAAK;AAAA,IACH,QAAQ;AAAA,IACR,WAAW;AAAA,IACX,WAAW;AAAA,IACX,sBAAsB;AAAA,IACtB,cAAc;AAAA,IACd,iBAAiB;AAAA,IACjB,0BAA0B;AAAA,IAC1B,wBAAwB;AAAA,EAC1B;AAAA,EACA,YAAY,EAAE,WAAW,GAAG,MAAM,MAAM,UAAU,GAAG,UAAU,EAAE;AAAA,EACjE,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,eAAe;AACjB;AACA,IAAM,iBAAiB,IAAI,IAAI,OAAO,KAAK,iBAAiB,YAAY,CAAC,CAAC;AAC1E,IAAM,aAAa,OAAO,KAAK,cAAc,YAAY,CAAC;AAQnD,SAAS,SACd,WACA,MACsD;AACtD,MAAI,CAAC,UAAW,QAAO,EAAE,QAAQ,QAAW,KAAK;AACjD,QAAM,SAAS,UAAU,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,OAAO;AAC5D,QAAM,UAAU,OAAO,OAAO,CAAC,MAAM,CAAC,WAAW,SAAS,CAAC,CAAC;AAC5D,MAAI,QAAQ,SAAS,EAAG,QAAO,EAAE,SAAS,OAAO,WAAW;AAC5D,SAAO,EAAE,QAAQ,MAAM,QAAQ,OAAO,KAAK,CAAC,MAAM,CAAC,eAAe,IAAI,CAAC,CAAC,EAAE;AAC5E;AAGO,SAAS,YAAY,QAAiB,MAA4B;AACvE,QAAM,OAAO,SAAS,SAAS,OAAO,MAAM,EAAE,MAAM,GAAG,IAAI,QAAW,QAAQ,IAAI,CAAC;AACnF,MAAI,EAAE,aAAa,MAAO,QAAO;AACjC,YAAU;AAAA,IACR,IAAI;AAAA,IACJ,OAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS,qBAAqB,KAAK,QAAQ,KAAK,IAAI,CAAC;AAAA,MACrD,KAAK;AAAA,QACH,QAAQ;AAAA,QACR,aAAa;AAAA,QACb,MAAM;AAAA,QACN,eAAe,KAAK;AAAA,QACpB,aAAa,KAAK;AAAA,MACpB;AAAA,IACF;AAAA,EACF,CAAC;AACD,UAAQ,KAAK,CAAC;AAChB;AAEO,SAAS,OAAO,KAAyB,MAA8C;AAC5F,SAAO,IAAI,IAAI,CAAC,MAAM;AACpB,UAAM,MAAM,oBAAoB,GAA8B,KAAK,IAAI;AACvE,WAAO,KAAK,SAAS,eAAe,KAAK,KAAK,MAAM,IAAI;AAAA,EAC1D,CAAC;AACH;","names":[]}

package/dist/chunk-QWX3QJNM.js

@@ -0,0 +1,170 @@
+import {
+  CONVERSION_COUNT_MODES,
+  findNameCollision,
+  isLandingViewKey,
+  parseEventKey
+} from "./chunk-7SX73SH2.js";
+
+// src/commands/analytics/conversionArgs.ts
+var ConversionArgsError = class extends Error {
+};
+function allValues(flag, argv) {
+  const values = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === flag) {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) values.push(next);
+      continue;
+    }
+    if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
+  }
+  return values.map((value) => value.trim()).filter((value) => value !== "");
+}
+function onlyOnce(value, flag, argv) {
+  if (value === void 0) return void 0;
+  const given = argv.filter((arg) => arg === flag || arg.startsWith(`${flag}=`)).length;
+  if (given > 1) {
+    throw new ConversionArgsError(
+      `${flag} was given ${given} times and only the last would have been used. It takes one value.`
+    );
+  }
+  const trimmed = String(value).trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function repeatable(flag, cittyValue, argv) {
+  const fromArgv = allValues(flag, argv);
+  if (fromArgv.length > 0) return fromArgv;
+  if (cittyValue === void 0) return [];
+  const trimmed = String(cittyValue).trim();
+  return trimmed === "" ? [] : [trimmed];
+}
+function checkFlagShape(args) {
+  if (args.eventKeys.length > 0 && args.name === void 0 && args.countMode === void 0) {
+    throw new ConversionArgsError(
+      "--event needs --name: a conversion nobody named is a row labelled with a UUID. (--event with only --count-mode changes how an event already counted is counted.)"
+    );
+  }
+  if (args.name !== void 0 && args.eventKeys.length === 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError("--name needs --event, naming which event to count.");
+  }
+  if (args.renameFrom !== void 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError('--rename needs --to: `--rename "Lead form" --to "Lead"`.');
+  }
+  if (args.renameTo !== void 0 && args.renameFrom === void 0) {
+    throw new ConversionArgsError(
+      '--to needs --rename, naming which outcome to rename: `--rename "Lead form" --to "Lead"`.'
+    );
+  }
+}
+function checkEventKeys(eventKeys) {
+  for (const eventKey of eventKeys) {
+    if (parseEventKey(eventKey) === null) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not an event key. Run with --candidates (or --flow <slug> for one Form) and copy one; they look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or exit:<host>.`
+      );
+    }
+    if (isLandingViewKey(eventKey)) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is a landing being viewed \u2014 a funnel step, never a conversion. Add it as a step with \`baker funnel\` instead.`
+      );
+    }
+  }
+}
+function readDays(raw) {
+  if (raw === void 0) return void 0;
+  const days = Number(raw);
+  if (!Number.isFinite(days) || days <= 0) {
+    throw new ConversionArgsError("--days must be a positive number of days.");
+  }
+  return days;
+}
+function parseConversionsArgs(raw, argv) {
+  const countMode = onlyOnce(raw["count-mode"], "--count-mode", argv);
+  if (countMode !== void 0 && !CONVERSION_COUNT_MODES.includes(countMode)) {
+    throw new ConversionArgsError(`--count-mode must be one of ${CONVERSION_COUNT_MODES.join(", ")}.`);
+  }
+  const args = {
+    eventKeys: repeatable("--event", raw.event, argv),
+    removeKeys: repeatable("--remove", raw.remove, argv),
+    name: onlyOnce(raw.name, "--name", argv),
+    countMode,
+    renameFrom: onlyOnce(raw.rename, "--rename", argv),
+    renameTo: onlyOnce(raw.to, "--to", argv),
+    removeName: onlyOnce(raw["remove-name"], "--remove-name", argv),
+    flowSlug: onlyOnce(raw.flow, "--flow", argv),
+    candidates: raw.candidates === true,
+    full: raw.full === true,
+    days: readDays(raw.days)
+  };
+  checkFlagShape(args);
+  checkEventKeys(args.eventKeys);
+  return args;
+}
+function existingNames(existing) {
+  return [...new Set(existing.map((row) => row.name))];
+}
+function checkNameCollision(name, existing) {
+  const collision = findNameCollision(name, existingNames(existing));
+  if (collision === null) return;
+  throw new ConversionArgsError(
+    `This company already counts "${collision}", and "${name}" would be a second row for the same outcome \u2014 Baker groups by exact name, so the number would be split in two. Use "${collision}" to make them one number, or pick a name that means something different.`
+  );
+}
+function under(name, existing) {
+  const rows = existing.filter((row) => row.name === name);
+  if (rows.length === 0) {
+    throw new ConversionArgsError(
+      `Nothing is counted under "${name}". This company counts: ${existingNames(existing).join(", ") || "nothing yet"}.`
+    );
+  }
+  return rows;
+}
+function setFromEvents(args, existing) {
+  if (args.eventKeys.length === 0) return [];
+  if (args.name !== void 0) {
+    checkNameCollision(args.name, existing);
+    const name = args.name;
+    return args.eventKeys.map((eventKey) => ({
+      eventKey,
+      name,
+      ...args.countMode ? { countMode: args.countMode } : {}
+    }));
+  }
+  return args.eventKeys.map((eventKey) => {
+    const current = existing.find((row) => row.eventKey === eventKey);
+    if (!current) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not counted, so there is no count mode to change. Add it with --event "${eventKey}" --name "<what a person calls it>" --count-mode ${args.countMode}.`
+      );
+    }
+    return { eventKey, name: current.name, countMode: args.countMode };
+  });
+}
+function setFromRename(args, existing) {
+  if (args.renameFrom === void 0 || args.renameTo === void 0) return [];
+  const renameTo = args.renameTo;
+  checkNameCollision(renameTo, existing);
+  return under(args.renameFrom, existing).map((row) => ({
+    eventKey: row.eventKey,
+    name: renameTo,
+    countMode: row.countMode
+  }));
+}
+function conversionsWrite(args, existing) {
+  const set = [...setFromEvents(args, existing), ...setFromRename(args, existing)];
+  const remove = [
+    ...args.removeKeys,
+    ...args.removeName === void 0 ? [] : under(args.removeName, existing).map((row) => row.eventKey)
+  ];
+  if (set.length === 0 && remove.length === 0) return null;
+  return { ...set.length > 0 ? { set } : {}, ...remove.length > 0 ? { remove } : {} };
+}
+
+export {
+  ConversionArgsError,
+  onlyOnce,
+  parseConversionsArgs,
+  conversionsWrite
+};
+//# sourceMappingURL=chunk-QWX3QJNM.js.map

package/dist/chunk-QXDEZKAR.js

@@ -0,0 +1,455 @@
+import {
+  writeJson
+} from "./chunk-4DM6OAQ6.js";
+
+// ../proxy/src/challenge.ts
+var CHALLENGE_PHRASES = [
+  "just a moment",
+  "attention required",
+  "verify you are human",
+  "checking your browser",
+  "enable javascript and cookies to continue",
+  "unusual traffic",
+  "access denied",
+  "you have been blocked",
+  "request unsuccessful",
+  "are you a robot",
+  "security check",
+  "ddos protection",
+  "captcha"
+];
+var CHALLENGE_MARKERS = ["cf-browser-verification", "cf_chl_", "px-captcha", "_incapsula_", "distil_r_captcha"];
+var CHALLENGE_LENGTH_CEILING = 2e3;
+function isChallengeBody(content, title) {
+  if (content.length <= CHALLENGE_LENGTH_CEILING) {
+    const haystack = `${title ?? ""}
+${content}`.toLowerCase();
+    if (CHALLENGE_PHRASES.some((phrase) => haystack.includes(phrase))) return true;
+  }
+  const whole = content.toLowerCase();
+  return CHALLENGE_MARKERS.some((marker) => whole.includes(marker));
+}
+
+// ../proxy/src/tiers.ts
+var PROXY_TIERS = {
+  datacenter: {
+    tier: "datacenter",
+    host: "dc.oxylabs.io",
+    port: 8e3,
+    usernamePrefix: "user-",
+    countryKey: "-country-",
+    sessionKey: null,
+    attempts: 3
+  },
+  residential: {
+    tier: "residential",
+    host: "pr.oxylabs.io",
+    port: 7777,
+    usernamePrefix: "customer-",
+    countryKey: "-cc-",
+    sessionKey: "-sessid-",
+    attempts: 1
+  }
+};
+var ESCALATION_ORDER = ["datacenter", "residential"];
+var KNOWN_USERNAME_PREFIXES = ["user-", "customer-"];
+
+// ../proxy/src/credentials.ts
+var PROXY_ENV_VARS = {
+  datacenter: { username: "OXYLABS_DATACENTER_USERNAME", password: "OXYLABS_DATACENTER_PASSWORD" },
+  residential: { username: "OXYLABS_RESIDENTIAL_USERNAME", password: "OXYLABS_RESIDENTIAL_PASSWORD" }
+};
+function readProxyCredentials(env) {
+  const credentials = {};
+  for (const tier of ESCALATION_ORDER) {
+    const username = env[PROXY_ENV_VARS[tier].username]?.trim();
+    const password = env[PROXY_ENV_VARS[tier].password]?.trim();
+    if (username && password) credentials[tier] = { username, password };
+  }
+  return credentials;
+}
+function configuredTiers(credentials) {
+  return ESCALATION_ORDER.filter((tier) => credentials[tier] !== void 0);
+}
+
+// ../proxy/src/escalate.ts
+var ESCALATABLE_STATUSES = /* @__PURE__ */ new Set([403, 429, 451]);
+var ESCALATABLE_NET_ERRORS = /* @__PURE__ */ new Set(["ERR_CONNECTION_RESET", "ERR_CONNECTION_CLOSED", "ERR_EMPTY_RESPONSE"]);
+var PROXY_NET_ERRORS = /* @__PURE__ */ new Set([
+  "ERR_TUNNEL_CONNECTION_FAILED",
+  "ERR_PROXY_CONNECTION_FAILED",
+  "ERR_PROXY_AUTH_REQUESTED",
+  "ERR_PROXY_CERTIFICATE_INVALID",
+  "ERR_UNEXPECTED_PROXY_AUTH",
+  "ERR_MANDATORY_PROXY_CONFIGURATION_FAILED",
+  "ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT"
+]);
+function isProxyFailure(signal) {
+  if (signal.status === 407) return true;
+  return signal.netError ? PROXY_NET_ERRORS.has(signal.netError) : false;
+}
+function shouldEscalate(signal) {
+  if (isProxyFailure(signal)) return false;
+  if (signal.timedOut) return false;
+  if (signal.challenge) return true;
+  if (signal.status != null && ESCALATABLE_STATUSES.has(signal.status)) return true;
+  return signal.netError ? ESCALATABLE_NET_ERRORS.has(signal.netError) : false;
+}
+
+// ../proxy/src/privateAddress.ts
+function isPrivateIpv4Octets(octets) {
+  const [a, b] = octets;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function parseIpv4(value) {
+  const parts = value.split(".");
+  if (parts.length !== 4) return null;
+  const octets = parts.map((part) => /^\d{1,3}$/.test(part) ? Number(part) : Number.NaN);
+  if (octets.some((octet) => !Number.isInteger(octet) || octet < 0 || octet > 255)) return null;
+  return octets;
+}
+function expandGroups(part) {
+  if (part === "") return [];
+  const chunks = part.split(":");
+  const groups = [];
+  for (let index = 0; index < chunks.length; index++) {
+    const chunk = chunks[index];
+    if (chunk.includes(".")) {
+      if (index !== chunks.length - 1) return null;
+      const octets = parseIpv4(chunk);
+      if (!octets) return null;
+      groups.push(octets[0] << 8 | octets[1]);
+      groups.push(octets[2] << 8 | octets[3]);
+      continue;
+    }
+    if (!/^[0-9a-f]{1,4}$/.test(chunk)) return null;
+    groups.push(Number.parseInt(chunk, 16));
+  }
+  return groups;
+}
+function parseIpv6(value) {
+  const halves = value.split("::");
+  if (halves.length > 2) return null;
+  const head = expandGroups(halves[0]);
+  const tail = halves.length === 2 ? expandGroups(halves[1]) : [];
+  if (head === null || tail === null) return null;
+  if (halves.length === 1) return head.length === 8 ? head : null;
+  const missing = 8 - head.length - tail.length;
+  if (missing < 1) return null;
+  return [...head, ...new Array(missing).fill(0), ...tail];
+}
+function isPrivateAddress(ip) {
+  const address = ip.trim().toLowerCase();
+  if (!address) return true;
+  const v4 = parseIpv4(address);
+  if (v4) return isPrivateIpv4Octets(v4);
+  const v6 = parseIpv6(address);
+  if (!v6) return true;
+  const [g0, g1, g2, g3, g4, g5, g6, g7] = v6;
+  if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0 && g6 === 0) return true;
+  const mappedV4 = g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0;
+  if (mappedV4 && g4 === 0 && g5 === 65535) {
+    return isPrivateIpv4Octets([g6 >> 8, g6 & 255, g7 >> 8, g7 & 255]);
+  }
+  if (mappedV4 && g4 === 65535 && g5 === 0) {
+    return isPrivateIpv4Octets([g6 >> 8, g6 & 255, g7 >> 8, g7 & 255]);
+  }
+  if ((g0 & 65024) === 64512) return true;
+  if ((g0 & 65472) === 65152) return true;
+  return false;
+}
+
+// ../proxy/src/publicAddress.ts
+var PRIVATE_HOST = /^(localhost|.*\.localhost|.*\.local)$/;
+var SANDBOX_HOST = /\.e2b\.(app|dev)$/;
+function unwrapIpLiteral(host) {
+  if (host.startsWith("[") && host.endsWith("]")) return host.slice(1, -1);
+  if (/^[0-9.]+$/.test(host) || host.includes(":")) return host;
+  return null;
+}
+function isPrivateHostname(hostname) {
+  const host = hostname.trim().toLowerCase();
+  if (!host) return true;
+  if (PRIVATE_HOST.test(host) || SANDBOX_HOST.test(host)) return true;
+  const literal = unwrapIpLiteral(host);
+  return literal === null ? false : isPrivateAddress(literal);
+}
+var BROWSER_PROXY_BYPASS = [
+  "localhost",
+  "*.localhost",
+  "127.0.0.1",
+  "0.0.0.0",
+  "::1",
+  "*.local",
+  // A Session's own preview, which is served from the sandbox's public host —
+  // public in DNS, ours in every sense that matters here.
+  "*.e2b.app",
+  "*.e2b.dev",
+  "10.*",
+  "192.168.*",
+  "169.254.*",
+  ...Array.from({ length: 16 }, (_, i) => `172.${16 + i}.*`)
+].join(",");
+function refuseNonPublicUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return "unparseable";
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return "not_public";
+  return isPrivateHostname(parsed.hostname) ? "not_public" : null;
+}
+
+// ../proxy/src/route.ts
+var DIRECT_ROUTE = { kind: "direct" };
+function proxyUsername(spec, rawUsername, options) {
+  const raw = rawUsername.trim();
+  const foreignPrefix = KNOWN_USERNAME_PREFIXES.find(
+    (prefix) => prefix !== spec.usernamePrefix && raw.startsWith(prefix)
+  );
+  if (foreignPrefix) return { ok: false, problem: "wrong_prefix" };
+  let username = raw.startsWith(spec.usernamePrefix) ? raw : `${spec.usernamePrefix}${raw}`;
+  if (options?.country) username += `${spec.countryKey}${options.country.toUpperCase()}`;
+  if (options?.session && spec.sessionKey) username += `${spec.sessionKey}${options.session}`;
+  return { ok: true, username };
+}
+function buildProxyRoute(tier, credentials, options) {
+  const held = credentials[tier];
+  if (!held) return { ok: false, problem: "missing" };
+  const spec = PROXY_TIERS[tier];
+  const username = proxyUsername(spec, held.username, options);
+  if (!username.ok) return username;
+  return {
+    ok: true,
+    route: {
+      kind: "proxy",
+      tier,
+      server: `http://${spec.host}:${spec.port}`,
+      username: username.username,
+      password: held.password
+    }
+  };
+}
+
+// ../proxy/src/ladder.ts
+function plannedRoutes(url, credentials, options) {
+  if (refuseNonPublicUrl(url) !== null) return [DIRECT_ROUTE];
+  const routes = [DIRECT_ROUTE];
+  for (const tier of configuredTiers(credentials)) {
+    const built = buildProxyRoute(tier, credentials, options);
+    if (!built.ok) continue;
+    for (let attempt = 0; attempt < PROXY_TIERS[tier].attempts; attempt++) routes.push(built.route);
+  }
+  return routes;
+}
+function routeTier(route) {
+  return route.kind === "proxy" ? route.tier : "direct";
+}
+function nextPlannedRoute(routes, tried) {
+  const dead = new Set(tried.filter((attempt) => attempt.proxyFailure).map((attempt) => attempt.tier));
+  const spent = /* @__PURE__ */ new Map();
+  for (const attempt of tried) spent.set(attempt.tier, (spent.get(attempt.tier) ?? 0) + 1);
+  const offered = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const tier = routeTier(route);
+    if (dead.has(tier)) continue;
+    const position = (offered.get(tier) ?? 0) + 1;
+    offered.set(tier, position);
+    if (position > (spent.get(tier) ?? 0)) return route;
+  }
+  return null;
+}
+
+// src/env.ts
+import { createEnv } from "@t3-oss/env-core";
+import { z } from "zod";
+
+// src/apiKeyFormat.ts
+var KEY_PREFIXES = ["bk_", "bkr_", "bkv_"];
+var API_KEY_FORMAT_MESSAGE = "API key must start with 'bk_', 'bkr_' or 'bkv_'";
+function isBakerApiKey(value) {
+  return KEY_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+
+// src/env.ts
+var cached;
+var CONNECTION = {
+  BAKER_API_KEY: z.string().refine(isBakerApiKey, API_KEY_FORMAT_MESSAGE),
+  BAKER_API_URL: z.url("BAKER_API_URL must be a valid URL")
+};
+function getEnv() {
+  if (!cached) {
+    cached = createEnv({
+      server: {
+        ...CONNECTION,
+        BAKER_PUBLIC_API_URL: z.url("BAKER_PUBLIC_API_URL must be a valid URL").optional(),
+        BAKER_CHAT_ID: z.string().optional(),
+        BAKER_THREAD_ID: z.string().optional(),
+        BAKER_KEY_SCOPE: z.enum(["report"]).optional(),
+        BAKER_ACTING_USER_ID: z.string().optional(),
+        BAKER_GOOGLE_ADS_CUSTOMER_ID: z.string().regex(/^\d{10}$/).optional(),
+        BAKER_GA4_PROPERTY_ID: z.string().optional(),
+        BAKER_GSC_SITE_URL: z.string().optional(),
+        BAKER_X_ADS_ACCOUNT_ID: z.string().regex(/^[a-z0-9]+$/, "X Ads account ID must be a base36 string").optional(),
+        BAKER_META_AD_ACCOUNT_ID: z.string().optional(),
+        BAKER_LINKEDIN_AD_ACCOUNT_ID: z.string().regex(/^\d+$/, "LinkedIn ad account ID must be the numeric portion of urn:li:sponsoredAccount:N").optional()
+      },
+      runtimeEnv: process.env,
+      onValidationError: refuseInvalidEnv
+    });
+  }
+  return cached;
+}
+function requireConnection() {
+  return createEnv({ server: CONNECTION, runtimeEnv: process.env, onValidationError: refuseInvalidEnv });
+}
+function issueVariable(issue) {
+  const first = issue.path?.[0];
+  const key = typeof first === "object" && first !== null ? first.key : first;
+  return key === void 0 ? "environment" : String(key);
+}
+var AGENT_SET_VARIABLES = /* @__PURE__ */ new Set([
+  "BAKER_GOOGLE_ADS_CUSTOMER_ID",
+  "BAKER_LINKEDIN_AD_ACCOUNT_ID",
+  "BAKER_X_ADS_ACCOUNT_ID"
+]);
+function listVariables(variables) {
+  return `${variables.join(", ")} ${variables.length === 1 ? "is" : "are"}`;
+}
+function refuseInvalidEnv(issues) {
+  const problems = issues.map((issue) => `${issueVariable(issue)}: ${issue.message}`).join("; ");
+  const variables = [...new Set(issues.map(issueVariable))];
+  if (variables.every((variable) => AGENT_SET_VARIABLES.has(variable))) {
+    writeJson({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: `An environment variable has the wrong format \u2014 ${problems}.`,
+        retryable: false,
+        fix: {
+          action: "retry_with_changes",
+          explanation: `${listVariables(variables)} an optional override set in this workspace, not by the platform. Export it again in the format named above, or unset ${variables.join(" and ")} and pass the account with the command's flag instead, then re-run the command.`
+        }
+      }
+    });
+    process.exit(1);
+  }
+  writeJson({
+    ok: false,
+    error: {
+      code: "NOT_CONFIGURED",
+      message: `This workspace's Baker connection is misconfigured \u2014 ${problems}.`,
+      retryable: false,
+      fix: {
+        action: "continue_without",
+        explanation: `${listVariables(variables)} set by the platform when this workspace starts, and nothing in this workspace can correct it \u2014 do not retry, and do not set or edit it yourself. Every command that reads or writes Baker data will fail the same way. Carry on with work that does not need Baker's data (files in the repo, local checks), and tell the user that reading and saving their Baker data is unavailable in this conversation until the platform fixes it.`
+      }
+    }
+  });
+  process.exit(1);
+}
+function optionalChatId() {
+  return process.env.BAKER_CHAT_ID || void 0;
+}
+function optionalTurnId() {
+  return process.env.BAKER_TURN_ID || void 0;
+}
+function debugLogSetting() {
+  const raw = process.env.BAKER_DEBUG_LOG?.trim();
+  return raw ? raw : void 0;
+}
+var MissingChatIdError = class extends Error {
+  code = "MISSING_CHAT_ID";
+  constructor() {
+    super(
+      "BAKER_CHAT_ID is not set. This command stages changes against a chat \u2014 run it from a chat-attached environment."
+    );
+    this.name = "MissingChatIdError";
+  }
+};
+function canvasAssetOriginsSetting() {
+  const raw = process.env.BAKER_CANVAS_ASSET_ORIGINS?.trim();
+  return raw ? raw : void 0;
+}
+function optionalConnection() {
+  const apiKey = process.env.BAKER_API_KEY;
+  const baseUrl = process.env.BAKER_API_URL;
+  return apiKey && baseUrl ? { apiKey, baseUrl } : null;
+}
+function requireChatId() {
+  const env = getEnv();
+  if (!env.BAKER_CHAT_ID) {
+    throw new MissingChatIdError();
+  }
+  return env.BAKER_CHAT_ID;
+}
+function resolveChatId(chat) {
+  return typeof chat === "string" && chat.length > 0 ? chat : requireChatId();
+}
+function hasFrameVisionKey() {
+  return Boolean(frameVisionKey());
+}
+function frameVisionKey() {
+  return process.env.GEMINI_API_KEY;
+}
+function openRouterKey() {
+  return process.env.OPENROUTER_API_KEY;
+}
+function hasOpenRouterKey() {
+  return Boolean(openRouterKey());
+}
+function captureBudgetMs() {
+  const raw = Number(process.env.BAKER_CAPTURE_BUDGET_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : null;
+}
+function captureProxyCredentials() {
+  return readProxyCredentials(process.env);
+}
+function captureVimeoCookie() {
+  const raw = process.env.VIMEO_COOKIE?.trim();
+  return raw ? raw : void 0;
+}
+function childEnvWith(extra) {
+  return { ...process.env, ...extra };
+}
+
+export {
+  isChallengeBody,
+  isProxyFailure,
+  shouldEscalate,
+  isPrivateAddress,
+  refuseNonPublicUrl,
+  DIRECT_ROUTE,
+  plannedRoutes,
+  nextPlannedRoute,
+  API_KEY_FORMAT_MESSAGE,
+  isBakerApiKey,
+  getEnv,
+  requireConnection,
+  optionalChatId,
+  optionalTurnId,
+  debugLogSetting,
+  MissingChatIdError,
+  canvasAssetOriginsSetting,
+  optionalConnection,
+  requireChatId,
+  resolveChatId,
+  hasFrameVisionKey,
+  frameVisionKey,
+  openRouterKey,
+  hasOpenRouterKey,
+  captureBudgetMs,
+  captureProxyCredentials,
+  captureVimeoCookie,
+  childEnvWith
+};
+//# sourceMappingURL=chunk-QXDEZKAR.js.map