@koda-sl/baker-cli 0.571.0-dev.6a3439a0a → 0.572.0

package/dist/chunk-QVO5VPNA.js

@@ -0,0 +1,169 @@
+import {
+  parseXApiError
+} from "./chunk-FIN4ZXGJ.js";
+import {
+  resolveXAccountId
+} from "./chunk-3GXHML4V.js";
+import {
+  writeAdsJson,
+  writeJsonEnvelope
+} from "./chunk-MPTNN35I.js";
+import {
+  X_DRAFT_BATCH_MAX,
+  xDraftOpInputSchema
+} from "./chunk-ICASR3ES.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-LJEJCIHR.js";
+import {
+  requireChatId
+} from "./chunk-B64KJW5C.js";
+
+// src/commands/ads/x/write-shared.ts
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function failPreflight(fields) {
+  writeJsonEnvelope({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: fields.map((f) => f.path ? `${f.path}: ${f.message}` : f.message).join("; "),
+      fields,
+      fix: {
+        action: "reject",
+        explanation: "Fix the named fields and stage again. Nothing was staged \u2014 the draft is exactly as it was before this call."
+      }
+    }
+  });
+  process.exit(1);
+}
+function handleXWriteError(err, accountId) {
+  if (err instanceof ApiError) {
+    writeAdsJson(parseXApiError(err.message, accountId));
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function decimalPlaces(value) {
+  const [mantissa, exponent] = String(value).trim().split(/e/i);
+  const written = (mantissa?.split(".")[1] ?? "").length;
+  return Math.max(0, written - (exponent ? Number(exponent) : 0));
+}
+function parseXMoney(value) {
+  if (value === void 0 || value === "") {
+    return { ok: true, micros: void 0 };
+  }
+  const amount = Number(value);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return { ok: false, reason: "must be a positive amount, for example 12.50" };
+  }
+  if (decimalPlaces(value) > 6) {
+    return { ok: false, reason: "is finer than X can express \u2014 it takes whole micros" };
+  }
+  return { ok: true, micros: Math.round(amount * 1e6) };
+}
+function microsFromArg(value, flag) {
+  const parsed = parseXMoney(value);
+  if (!parsed.ok) {
+    failWriteValidation(`${flag} ${parsed.reason}`);
+  }
+  return parsed.micros;
+}
+function csvArg(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function compact(payload) {
+  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== void 0));
+}
+function batchNudge(data) {
+  const count = data?.sameKindStaged;
+  if (!count) {
+    return [];
+  }
+  return [
+    `${count} other change${count === 1 ? "" : "s"} of this kind and payload ${count === 1 ? "is" : "are"} already staged \u2014 pass every id to one call (\`--ids a,b,c\`) instead of one call each.`
+  ];
+}
+async function stageXOp(raw, hints) {
+  const preflight = xDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    failPreflight(preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message })));
+  }
+  const accountId = String(raw.accountId ?? "\u2014");
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/x/draft/stage", { chatId, op: preflight.data });
+    const allHints = [...batchNudge(response.data), ...hints ?? []];
+    writeJsonEnvelope(allHints.length > 0 ? { ...response, hints: allHints } : response);
+  } catch (err) {
+    handleXWriteError(err, accountId);
+  }
+}
+async function stageXOps(rawOps, hints) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageXOp(rawOps[0], hints);
+    return;
+  }
+  if (rawOps.length > X_DRAFT_BATCH_MAX) {
+    failWriteValidation(`at most ${X_DRAFT_BATCH_MAX} changes can be staged in one call`);
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = xDraftOpInputSchema.safeParse(raw);
+    if (!preflight.success) {
+      failPreflight(
+        preflight.error.issues.map((issue) => ({
+          path: `ops[${index}]${issue.path.length > 0 ? `.${issue.path.join(".")}` : ""}`,
+          message: issue.message
+        }))
+      );
+    }
+    ops.push(preflight.data);
+  }
+  const accountId = String(rawOps[0]?.accountId ?? "\u2014");
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/x/draft/stage-batch", { chatId, ops });
+    writeJsonEnvelope(hints && hints.length > 0 ? { ...response, hints } : response);
+  } catch (err) {
+    handleXWriteError(err, accountId);
+  }
+}
+async function stageAccountId(args) {
+  return await resolveXAccountId(args);
+}
+function requireTarget(args, name) {
+  const value = args[name];
+  if (typeof value !== "string" || value.length === 0) {
+    failWriteValidation(`${name} is required`);
+  }
+  return value;
+}
+function requireTargets(args, name) {
+  const ids = csvArg(args[name]);
+  if (!ids) {
+    failWriteValidation(`${name} is required \u2014 pass one or more ids, comma-separated`);
+  }
+  return ids;
+}
+
+export {
+  failWriteValidation,
+  microsFromArg,
+  csvArg,
+  compact,
+  stageXOp,
+  stageXOps,
+  stageAccountId,
+  requireTarget,
+  requireTargets
+};
+//# sourceMappingURL=chunk-QVO5VPNA.js.map

package/dist/chunk-RBR5PHYJ.js

@@ -0,0 +1,91 @@
+import {
+  definitionPlatformOf,
+  parseDefinitionDelivery,
+  resolveDelivery,
+  resolveFormatList
+} from "./chunk-C4BPAMAJ.js";
+import {
+  AD_PLACEMENTS
+} from "./chunk-MCJ5I5LR.js";
+import {
+  CAPABILITY_SURFACES
+} from "./chunk-R7XDGNZD.js";
+import {
+  apiPost
+} from "./chunk-LJEJCIHR.js";
+
+// src/commands/canvas/scaffold-delivery.ts
+var flagText = (value) => typeof value === "string" || typeof value === "number" ? String(value).trim() || void 0 : void 0;
+function deliveryInputOf(flags, definition, idea) {
+  const platformsFlag = flagText(flags.platforms);
+  const legacyPlatform = flagText(flags.platform);
+  const legacyPlacements = flagText(flags.placements);
+  const aspect = flagText(flags.aspect);
+  const formatsFlag = flagText(flags.formats);
+  const targetAdSet = flagText(flags["target-adset"]);
+  return {
+    ...platformsFlag ? { platformsFlag } : {},
+    ...legacyPlatform ? { legacyPlatform } : {},
+    ...legacyPlacements ? { legacyPlacements } : {},
+    ...aspect ? { aspect } : {},
+    ...formatsFlag ? { formatsFlag } : {},
+    ...idea && idea.length > 0 ? { idea } : {},
+    definition,
+    ...targetAdSet ? { targetAdSet } : {}
+  };
+}
+function namesDelivery(flags) {
+  return [flags.platforms, flags.platform, flags.placements, flags.formats].some((f) => flagText(f) !== void 0);
+}
+var SURFACE_PLATFORMS = {
+  "meta-ads": "meta",
+  "linkedin-ads": "linkedin",
+  "google-ads": "google_demandgen",
+  "x-ads": "x",
+  "chatgpt-ads": "chatgpt"
+};
+async function connectedAdPlatforms() {
+  try {
+    const response = await apiPost("/api/capabilities", {}, { timeoutMs: 15e3 });
+    return response.data.surfaces.filter((s) => s.connected && CAPABILITY_SURFACES.includes(s.surface)).flatMap((s) => SURFACE_PLATFORMS[s.surface] ? [SURFACE_PLATFORMS[s.surface]] : []);
+  } catch {
+    return [];
+  }
+}
+async function scaffoldDelivery(flags, definitionText, idea) {
+  const definition = definitionText === null ? null : parseDefinitionDelivery(definitionText);
+  const input = deliveryInputOf(flags, definition, idea);
+  const resolved = resolveDelivery(input);
+  if (resolved.ok || resolved.error.code !== "platform_required") return resolved;
+  return resolveDelivery({ ...input, connected: await connectedAdPlatforms() });
+}
+function deliveryDefinitionFields(delivery) {
+  const platforms = delivery.platforms.map((p) => p.trim());
+  return {
+    // The collection names whole platforms; a placement named alone records its platform.
+    platforms: [...new Set(platforms.map(platformOfName))],
+    platform: definitionPlatformOf(platforms[0] ?? ""),
+    formats: resolveFormatList(delivery.formats)
+  };
+}
+function platformOfName(name) {
+  return AD_PLACEMENTS.find((p) => p.id === name)?.platform ?? name;
+}
+function deliveryNote(delivery, renderRatio) {
+  const from = {
+    flag: "as asked",
+    idea: "from the idea",
+    definition: "from _definition.md",
+    legacy_definition: "from _definition.md's platform",
+    adset: "from its Meta ad set"
+  };
+  return `Made for ${delivery.platforms.join(", ")} (${from[delivery.source]}): delivers ${delivery.formats.join(", ")}, the ${delivery.lead} designed first (rendered at ${renderRatio}) and every other size re-laid out from it.`;
+}
+
+export {
+  namesDelivery,
+  scaffoldDelivery,
+  deliveryDefinitionFields,
+  deliveryNote
+};
+//# sourceMappingURL=chunk-RBR5PHYJ.js.map

package/dist/chunk-RHBCKOF2.js

@@ -0,0 +1,61 @@
+import {
+  COST_TYPES,
+  OBJECTIVE_TYPES,
+  calendarDaySchema,
+  targetingCriteriaSchema
+} from "./chunk-ICASR3ES.js";
+
+// ../api/src/ads-linkedin/planning.ts
+import { z } from "zod";
+var moneySchema = z.object({
+  amount: z.string().regex(/^\d+(\.\d+)?$/, "use a plain amount such as 250 or 5.57"),
+  currencyCode: z.string().regex(/^[A-Z]{3}$/).optional()
+});
+var accountIdSchema = z.string().min(1);
+var linkedinBidPricingRequestSchema = z.object({
+  accountId: accountIdSchema,
+  objectiveType: z.enum(OBJECTIVE_TYPES),
+  costType: z.enum(COST_TYPES).default("CPC"),
+  campaignType: z.enum(["SPONSORED_UPDATES", "TEXT_AD", "SPONSORED_INMAILS"]).default("SPONSORED_UPDATES"),
+  /** EXACT = audience expansion off, the playbook default. */
+  matchType: z.enum(["EXACT", "AUDIENCE_EXPANDED"]).default("EXACT"),
+  targetingCriteria: targetingCriteriaSchema,
+  skipCache: z.boolean().optional()
+});
+var LINKEDIN_FORECAST_DEFAULT_DAYS = 30;
+var linkedinForecastRequestSchema = z.object({
+  accountId: accountIdSchema,
+  objectiveType: z.enum(OBJECTIVE_TYPES).optional(),
+  costType: z.enum(COST_TYPES).default("CPC"),
+  campaignType: z.enum(["SPONSORED_UPDATES", "SPONSORED_INMAILS", "DYNAMIC"]).default("SPONSORED_UPDATES"),
+  /** First forecast day (UTC); defaults to tomorrow — LinkedIn forecasts only the future. */
+  startDate: calendarDaySchema.optional(),
+  days: z.number().int().min(1).max(365).default(LINKEDIN_FORECAST_DEFAULT_DAYS),
+  dailyBudget: moneySchema.optional(),
+  totalBudget: moneySchema.optional(),
+  /** A manual bid; without one LinkedIn forecasts its automated bidding. */
+  bid: moneySchema.optional(),
+  optimizationTarget: z.string().regex(/^[A-Z_]+$/).optional(),
+  targetingCriteria: targetingCriteriaSchema,
+  /** Add LinkedIn's raw series (daily, 7-day, 30-day) to the summary. */
+  full: z.boolean().default(false),
+  skipCache: z.boolean().optional()
+}).superRefine((req, ctx) => {
+  if (!req.dailyBudget && !req.totalBudget) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["totalBudget"],
+      message: "a budget is required (daily or total) \u2014 LinkedIn forecasts what a budget buys"
+    });
+  }
+  if (req.dailyBudget && req.totalBudget) {
+    ctx.addIssue({ code: "custom", path: ["totalBudget"], message: "pass a daily or a total budget, not both" });
+  }
+});
+
+export {
+  linkedinBidPricingRequestSchema,
+  LINKEDIN_FORECAST_DEFAULT_DAYS,
+  linkedinForecastRequestSchema
+};
+//# sourceMappingURL=chunk-RHBCKOF2.js.map