@koda-sl/baker-cli 0.461.0 → 0.462.0

package/dist/export-Z7ECLZHA.js

@@ -0,0 +1,168 @@
+import {
+  reportError
+} from "./chunk-ECRSLUOF.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-D4N5ZXEO.js";
+import "./chunk-QYDJJLEE.js";
+import "./chunk-NBPJBJJD.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4TCMKTJG.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/export.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+function exportStartHints(args) {
+  const hints = [
+    "This downloads the PUBLISHED site \u2014 landings changed in this chat and not yet published are not included. Publish first if the user wants them in it.",
+    "It takes a few minutes. Don't wait on it: carry on, then run `baker landing export status <id>` for the link. The user also sees it in this chat's changes, with a download button once it is ready."
+  ];
+  if (args.stagedProfilePending && !args.profileOverridden) {
+    hints.push(
+      "This chat has a download-format change waiting on Publish; this export uses the saved format. The staged format applies after publish \u2014 pass `--profile` to try it now."
+    );
+  }
+  return hints;
+}
+function exportStatusHints(view) {
+  if (view.status === "ready") {
+    return view.downloadUrl ? ["Give the user this link to download the ZIP \u2014 it is also on this chat's changes."] : ["This export is ready but its file is gone. Start a new one with `baker landing export start`."];
+  }
+  if (view.status === "error") {
+    return [
+      "This export failed. Tell the user it could not be prepared and start a new one with `baker landing export start`; if it fails again, they can export from Landings."
+    ];
+  }
+  return ["Still being prepared. Carry on with other work and check again in a minute \u2014 never sleep-loop on it."];
+}
+function parseProfileFlag(raw, readFile = (path) => readFileSync(path, "utf8")) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.startsWith("@") ? readFile(raw.slice(1)) : raw);
+  } catch (error) {
+    return {
+      ok: false,
+      message: `--profile must be a JSON object or @<file> holding one: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { ok: false, message: `--profile must be a JSON object, e.g. '{"htmlOutput":"fragment"}'.` };
+  }
+  return { ok: true, profile: parsed };
+}
+function failValidation(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+registerSchema({
+  command: "landing.export.start",
+  description: "Start a download (ZIP of plain HTML) of the company's PUBLISHED landings \u2014 the same pack Landings \u2192 Export makes. Returns at once with an id; the pack takes a few minutes. Unpublished changes in this chat are not in it. No password option: a protected pack is made from the dashboard.",
+  args: {
+    profile: {
+      type: "string",
+      description: `Download-format fields for this export only, on top of the saved format: a JSON object or @<file>. Example: '{"htmlOutput":"fragment","inlineCss":true}'`,
+      required: false
+    }
+  }
+});
+registerSchema({
+  command: "landing.export.status",
+  description: "Where one download got to, and its link once it is ready.",
+  args: { id: { type: "string", description: "Export id from `start` or `list`", required: true } }
+});
+registerSchema({
+  command: "landing.export.list",
+  description: "The company's last 10 downloads, newest first, with their status. `status <id>` gives the link.",
+  args: {}
+});
+var startCommand = defineCommand({
+  meta: {
+    name: "start",
+    description: "Start a download of the published landings. Examples: baker landing export start | baker landing export start --profile @export-profile.json"
+  },
+  args: {
+    profile: {
+      type: "string",
+      description: "Download-format fields for this export only (JSON object or @file)",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const rawProfile = typeof args.profile === "string" ? args.profile : void 0;
+    const body = {};
+    if (rawProfile !== void 0) {
+      const parsed = parseProfileFlag(rawProfile);
+      if (!parsed.ok) failValidation(parsed.message);
+      body.profile = parsed.profile;
+    }
+    try {
+      const response = await apiPost("/api/landings/export/start", body);
+      writeJson({
+        ok: true,
+        data: { exportId: response.data.exportId },
+        hints: exportStartHints({
+          stagedProfilePending: response.data.stagedProfilePending,
+          profileOverridden: rawProfile !== void 0
+        })
+      });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Where a download got to, and its link once ready. Example: baker landing export status <id>"
+  },
+  args: { id: { type: "positional", description: "Export id", required: true } },
+  run: async ({ args }) => {
+    try {
+      const response = await apiGet("/api/landings/export/status", {
+        id: String(args.id)
+      });
+      writeJson({ ok: true, data: response.data, hints: exportStatusHints(response.data) });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "The company's last 10 downloads. Example: baker landing export list" },
+  args: {},
+  run: async () => {
+    try {
+      const response = await apiGet("/api/landings/export/list");
+      writeJson({ ok: true, data: response.data });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+var exportCommand = defineCommand({
+  meta: {
+    name: "export",
+    description: `Download the company's published landings as a ZIP of plain HTML.
+
+Start here: \`baker landing export start\`, then \`baker landing export status <id>\` for the link.
+
+Subcommands:
+  baker landing export start [--profile <json|@file>] \u2014 start a download (returns at once)
+  baker landing export status <id>                    \u2014 progress, and the link once ready
+  baker landing export list                           \u2014 the last 10 downloads
+
+Full guide: __tooling__/docs/tools/baker/landing.md`
+  },
+  subCommands: { start: startCommand, status: statusCommand, list: listCommand }
+});
+export {
+  exportCommand,
+  exportStartHints,
+  exportStatusHints,
+  parseProfileFlag
+};
+//# sourceMappingURL=export-Z7ECLZHA.js.map

package/dist/extract-FQ3JAT26.js

@@ -0,0 +1,113 @@
+import {
+  AUTO_INGEST_MAX,
+  parseAutoIngest
+} from "./chunk-KKJ4KJCW.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-D4N5ZXEO.js";
+import "./chunk-QYDJJLEE.js";
+import "./chunk-NBPJBJJD.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4TCMKTJG.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/extract.ts
+import { defineCommand } from "citty";
+
+// src/commands/images/extractErrors.ts
+var RETRYABLE = /* @__PURE__ */ new Set(["UNAVAILABLE", "RATE_LIMITED", "TIMEOUT", "NETWORK_ERROR"]);
+function extractErrorEnvelope(err, url) {
+  const retryable = RETRYABLE.has(err.code);
+  const fallback = `use \`baker images screenshot ${url}\` to capture the page as one image, or \`baker images logo <domain>\` for the brand's mark, and carry on with the rest of the job.`;
+  return {
+    ok: false,
+    error: {
+      code: err.code,
+      message: err.message,
+      retryable,
+      fix: retryable ? { action: "retry_once", explanation: `Run the same command once more. If it fails again, ${fallback}` } : { action: "use_fallback", explanation: `Retrying the same address will fail the same way \u2014 ${fallback}` }
+    }
+  };
+}
+
+// src/commands/images/extract.ts
+registerSchema({
+  command: "images.extract",
+  description: "Extract images from a URL via Firecrawl (formats: images).",
+  args: {
+    url: { type: "string", description: "URL to scrape", required: true },
+    "wait-for": { type: "number", description: "JS render wait ms", required: false },
+    limit: { type: "number", description: "Limit returned images", required: false, default: 50 },
+    "auto-ingest": {
+      type: "number",
+      description: `Auto-ingest top N (0-${AUTO_INGEST_MAX.extract}, default 0)`,
+      required: false,
+      default: 0
+    },
+    context: {
+      type: "string",
+      description: "Free-text hint applied to every auto-ingested hit (overrides provider-derived context)",
+      required: false
+    }
+  }
+});
+var extractCommand = defineCommand({
+  meta: {
+    name: "extract",
+    description: "Pull every image from a single URL via Firecrawl. ~$0.001/scrape. Cap auto-ingest at 20.\n\nExample: baker images extract https://stripe.com --auto-ingest 5"
+  },
+  args: {
+    url: { type: "positional", description: "URL to scrape", required: false },
+    "wait-for": { type: "string", description: "JS render wait ms", required: false },
+    limit: { type: "string", description: "Max returned images", required: false },
+    "auto-ingest": { type: "string", description: `Auto-ingest top N (0-${AUTO_INGEST_MAX.extract})`, required: false },
+    context: { type: "string", description: "Description context hint applied to auto-ingested hits", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const url = args.url;
+      if (!url) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "URL is required" } });
+        process.exit(1);
+      }
+      const body = { url };
+      if (args["wait-for"]) body.waitFor = Number(args["wait-for"]);
+      if (args.limit) body.limit = Number(args.limit);
+      if (args["auto-ingest"] !== void 0) {
+        const parsed = parseAutoIngest(args["auto-ingest"], AUTO_INGEST_MAX.extract);
+        if (!parsed.ok) {
+          writeJson({
+            ok: false,
+            error: {
+              code: "VALIDATION_ERROR",
+              message: parsed.message,
+              fix: {
+                action: "retry_with_changes",
+                explanation: `Re-run with --auto-ingest in 0-${AUTO_INGEST_MAX.extract}.`
+              }
+            }
+          });
+          process.exit(1);
+        }
+        body.autoIngest = parsed.value;
+      }
+      if (args.context) body.descriptionContext = args.context;
+      const data = await apiPost("/api/images/extract", body);
+      writeJson({ ok: true, data });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson(extractErrorEnvelope(err, String(args.url)));
+        process.exit(1);
+      }
+      writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  extractCommand
+};
+//# sourceMappingURL=extract-FQ3JAT26.js.map

package/dist/facets-ZHL6A37H.js

@@ -0,0 +1,113 @@
+import {
+  csvOrJson,
+  handleLinkedinError
+} from "./chunk-WSYGMU3A.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-V44SLD5J.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X7ZODEXJ.js";
+import "./chunk-ZJVHZHYP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiGet
+} from "./chunk-D4N5ZXEO.js";
+import "./chunk-QYDJJLEE.js";
+import "./chunk-NBPJBJJD.js";
+import "./chunk-4TCMKTJG.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/facets.ts
+import { defineCommand } from "citty";
+var listCmd = defineCommand({
+  meta: {
+    name: "list",
+    description: `List every targeting facet LinkedIn supports.
+
+Cached 7 days. Use this to discover what dimensions you can target on (industries,
+seniorities, titles, employers, growthRate, companyCategory, skills, etc.).`
+  },
+  args: {
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    try {
+      const params = {};
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/facets", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var valuesCmd = defineCommand({
+  meta: {
+    name: "values",
+    description: `Look up entity values for a single facet \u2014 full list or typeahead search.
+
+Examples:
+  baker ads linkedin facets values --facet seniorities                          \u2014 all seniority URNs
+  baker ads linkedin facets values --facet titles --query "marketing director"  \u2014 typeahead
+  baker ads linkedin facets values --facet industries --output csv
+
+The --facet flag accepts the bare name (industries, seniorities, titles, etc.)
+or the full URN (urn:li:adTargetingFacet:industries).`
+  },
+  args: {
+    facet: { type: "string", description: "Facet name (e.g. industries) or URN", required: true },
+    query: { type: "string", description: "Typeahead query (auto-switches finder to typeahead)" },
+    finder: { type: "string", description: "adTargetingFacet | typeahead | similarEntities (default: auto)" },
+    locale: { type: "string", description: "Locale (default: en_US)" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    try {
+      const params = { facet: String(args.facet) };
+      const finder = args.finder ?? (args.query ? "typeahead" : "adTargetingFacet");
+      params.finder = finder;
+      if (args.query) params.query = String(args.query);
+      if (args.locale) params.locale = String(args.locale);
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/facets/entities", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var facetsCommand = defineCommand({
+  meta: {
+    name: "facets",
+    description: `LinkedIn targeting facets and entity lookup.
+
+Subcommands:
+  list                          \u2014 every facet (industries, seniorities, titles, employers, \u2026)
+  values --facet titles         \u2014 entity URNs for one facet
+  values --facet titles --query "marketing director"  \u2014 typeahead`
+  },
+  subCommands: {
+    list: listCmd,
+    values: valuesCmd
+  }
+});
+export {
+  facetsCommand
+};
+//# sourceMappingURL=facets-ZHL6A37H.js.map

package/dist/favorites-DAFSW4BB.js

@@ -0,0 +1,178 @@
+import {
+  INSPIRATION_HINTS,
+  favoritesScopeHints,
+  parseNumber,
+  reportError,
+  splitList
+} from "./chunk-ECRSLUOF.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-D4N5ZXEO.js";
+import "./chunk-QYDJJLEE.js";
+import "./chunk-NBPJBJJD.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4TCMKTJG.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/inspiration/favorites.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "landing.inspiration.favorites",
+  description: "List the reference sections this company has saved. This is what `search` looks at by default, so it is the client's own taste profile \u2014 read it before proposing a direction.",
+  args: {
+    type: { type: "string", description: "Comma list of section types to filter by", required: false },
+    limit: { type: "number", description: "Max results (default 30, capped at 100)", required: false },
+    full: {
+      type: "boolean",
+      description: "Add the transferable idea behind each saved section. Costs roughly 60% more; read the list first",
+      required: false
+    }
+  }
+});
+var favoritesCommand = defineCommand({
+  meta: {
+    name: "favorites",
+    description: "List this company's saved reference sections. Example: baker landing inspiration favorites --type hero,pricing"
+  },
+  args: {
+    type: { type: "string", description: "Comma list of section types", required: false },
+    limit: { type: "string", description: "Max results (default 30, capped at 100)", required: false },
+    full: { type: "boolean", description: "Include why_it_works per section", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const params = {};
+      const types = splitList(args.type);
+      if (types) params.type = types.join(",");
+      const limit = parseNumber(args.limit);
+      if (limit !== void 0) params.limit = String(limit);
+      const data = await apiGet("/api/landing-inspiration/favorites", params);
+      const sections = Array.isArray(data?.sections) ? data.sections : [];
+      const full = args.full;
+      const saved = data.savedPages ?? void 0;
+      writeJson({
+        ok: true,
+        data: {
+          // The pages the client actually saved, alongside the sections those
+          // pages yielded. These are different numbers, and conflating them is
+          // how a company with 234 saved pages was told it had saved nothing:
+          // 211 of them failed to be read, so they contribute no sections, and
+          // the section list alone made a broken library look like an unused one.
+          ...saved ? {
+            saved_pages: {
+              total: saved.savedPages,
+              usable: saved.usablePages,
+              studying: saved.studyingPages,
+              unreadable: saved.failedPages,
+              ...saved.failedExamples.length > 0 ? { unreadable_examples: saved.failedExamples } : {}
+            }
+          } : {},
+          sections: sections.map((section) => ({
+            id: section.id,
+            page_id: section.sourceId,
+            section: section.sectionType,
+            composition: section.composition,
+            look: section.visualRegister,
+            domain: section.domain,
+            // Behind --full: this is a 600-character paragraph, and at the
+            // default 30 rows it was about 60% of the response. Reading a taste
+            // profile is a question about *what* the client keeps saving —
+            // types, compositions, which sites — and the essay per row answers
+            // a question you only have once you have picked a row.
+            ...full ? { why_it_works: section.whyItWorks } : {}
+          }))
+        },
+        hints: [
+          // What the saved set is actually in — an empty profile, a broken one,
+          // or a healthy one — before anything is said about the sections.
+          ...favoritesScopeHints(saved, sections.length),
+          ...sections.length === 0 ? saved && saved.savedPages > 0 ? [] : [
+            "Nothing saved yet. Add a page the client admires with `baker landing inspiration add <url>`, or browse the whole library with `baker landing inspiration search --scope all`."
+          ] : [
+            "These are the client's taste signals \u2014 read them as direction, not as a component library.",
+            ...full ? [] : ["Add --full for the transferable idea behind each one."],
+            INSPIRATION_HINTS.adapt
+          ]
+        ]
+      });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+registerSchema({
+  command: "landing.inspiration.favorite",
+  description: "Save a reference section (or a whole page) to this company, so it shows up in the default search scope.",
+  args: {
+    id: { type: "string", description: "Section id, or page id with --page", required: true },
+    page: { type: "boolean", description: "Treat the id as a page rather than a section", required: false },
+    note: { type: "string", description: "Why this is worth keeping", required: false }
+  }
+});
+var favoriteCommand = defineCommand({
+  meta: {
+    name: "favorite",
+    description: "Save a reference section to this company. Example: baker landing inspiration favorite k57abc\u2026"
+  },
+  args: {
+    id: { type: "positional", description: "Section id (or page id with --page)", required: true },
+    page: { type: "boolean", description: "Treat the id as a page", required: false, default: false },
+    note: { type: "string", description: "Why this is worth keeping", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id;
+      const body = args.page ? { sourceId: id } : { sectionId: id };
+      const data = await apiPost("/api/landing-inspiration/favorite", {
+        ...body,
+        note: args.note
+      });
+      writeJson({
+        ok: true,
+        data: { id, favorited: data.favorited },
+        hints: [
+          "Saved. `search` looks at this company's saved sections by default, so this now shows up without --scope all."
+        ]
+      });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+registerSchema({
+  command: "landing.inspiration.unfavorite",
+  description: "Remove a reference section (or page) from this company's saved set.",
+  args: {
+    id: { type: "string", description: "Section id, or page id with --page", required: true },
+    page: { type: "boolean", description: "Treat the id as a page rather than a section", required: false }
+  }
+});
+var unfavoriteCommand = defineCommand({
+  meta: {
+    name: "unfavorite",
+    description: "Remove a reference section from this company's saved set. Example: baker landing inspiration unfavorite k57abc\u2026"
+  },
+  args: {
+    id: { type: "positional", description: "Section id (or page id with --page)", required: true },
+    page: { type: "boolean", description: "Treat the id as a page", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id;
+      const body = args.page ? { sourceId: id } : { sectionId: id };
+      const data = await apiPost("/api/landing-inspiration/unfavorite", body);
+      writeJson({ ok: true, data: { id, favorited: data.favorited } });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+export {
+  favoriteCommand,
+  favoritesCommand,
+  unfavoriteCommand
+};
+//# sourceMappingURL=favorites-DAFSW4BB.js.map