@adkit/cli 1.12.28 → 1.12.30

package/dist/cli.js

@@ -744,14 +744,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve3(subprocess);
+        resolve4(subprocess);
       });
     });
   }
@@ -3195,10 +3195,303 @@ async function disconnectRedditAccount(client, args, flags) {
 }
 
 // src/commands/linkedin.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { basename as basename3, extname as extname3, resolve as resolve3 } from "node:path";
+var MEDIA_UPLOAD_FLAGS3 = ["file", "url", "base64", "adkit-media", "temporary-upload", "filename", "content-type", "name"];
+var CAMPAIGN_LIST_FLAGS3 = ["campaign-ids", "limit", "offset"];
+var AD_GROUP_LIST_FLAGS3 = ["campaign-ids", "ad-group-ids", "limit", "offset"];
+var AD_LIST_FLAGS3 = ["campaign-ids", "limit", "offset"];
+var CAMPAIGN_CREATE_FLAGS3 = ["name", "status", "budget-daily", "budget-lifetime", "end-date"];
+var AD_GROUP_CREATE_FLAGS2 = ["campaign", "name", "objective", "status", "budget-daily", "budget-lifetime"];
+var AD_CREATE_FLAGS2 = ["ad-group", "existing-post", "name", "status"];
+var CAMPAIGN_UPDATE_FLAGS3 = ["name", "status", "budget-lifetime", "end-date"];
+var AD_GROUP_UPDATE_FLAGS2 = ["name", "status", "budget-daily", "budget-lifetime", "start-date", "end-date"];
+var AD_UPDATE_FLAGS2 = ["name", "status"];
+var TARGETING_SEARCH_FLAGS = ["account", "facet", "query", "limit"];
+var RESULTS_FLAGS2 = ["level", "period", "fields", "breakdowns", "from", "to", "sort", "limit", "offset"];
 async function listLinkedInAvailableAccounts(client, _args, flags) {
   validateFlags(flags, [], "manage linkedin accounts available");
   return client.get("/manage/linkedin/accounts/available");
 }
+async function uploadLinkedInMedia(client, _args, flags) {
+  validateFlags(flags, MEDIA_UPLOAD_FLAGS3, "manage linkedin media upload");
+  if (typeof flags.data === "string") {
+    const body2 = parseDataFlag(flags, 'Use { "assets": [...] } for LinkedIn media upload');
+    const qs2 = buildLinkedInMutationQuery(flags);
+    return client.post(`/manage/linkedin/media${qs2}`, body2);
+  }
+  const source = buildLinkedInMediaUploadSource(flags);
+  const body = { assets: [source] };
+  const qs = buildLinkedInMutationQuery(flags);
+  return client.post(`/manage/linkedin/media${qs}`, body);
+}
+async function getLinkedInMedia(client, args, flags) {
+  validateFlags(flags, [], "manage linkedin media <urn>");
+  const id = requireArg(args, 0, "media-urn", "Run: adkit manage linkedin media <media-urn>");
+  const qs = buildLinkedInReadQuery(flags);
+  return client.get(`/manage/linkedin/media/${id}${qs}`);
+}
+async function listLinkedInCampaigns(client, _args, flags) {
+  validateFlags(flags, CAMPAIGN_LIST_FLAGS3, "manage linkedin campaigns list");
+  const qs = buildLinkedInListQuery(flags, ["campaign-ids"]);
+  return client.get(`/manage/linkedin/campaigns${qs}`);
+}
+async function getLinkedInCampaign(client, args, flags) {
+  validateFlags(flags, [], "manage linkedin campaigns <id>");
+  const id = requireArg(args, 0, "campaign-id", "Run: adkit manage linkedin campaigns <campaign-id>");
+  const qs = buildLinkedInReadQuery(flags);
+  return client.get(`/manage/linkedin/campaigns/${id}${qs}`);
+}
+async function createLinkedInCampaign(client, _args, flags) {
+  validateFlags(flags, CAMPAIGN_CREATE_FLAGS3, "manage linkedin campaigns create");
+  const qs = buildLinkedInMutationQuery(flags);
+  if (typeof flags.data === "string") {
+    const body2 = parseDataFlag(flags, 'Use { "campaigns": [...] } for LinkedIn campaign create');
+    return client.post(`/manage/linkedin/campaigns${qs}`, body2);
+  }
+  const body = { campaigns: [buildLinkedInCampaignPayload(flags)] };
+  return client.post(`/manage/linkedin/campaigns${qs}`, body);
+}
+async function updateLinkedInCampaign(client, args, flags) {
+  validateFlags(flags, CAMPAIGN_UPDATE_FLAGS3, "manage linkedin campaigns update");
+  const id = requireArg(args, 0, "campaign-id", "Run: adkit manage linkedin campaigns update <campaign-id> --status paused");
+  const qs = buildLinkedInMutationQuery(flags);
+  const body = typeof flags.data === "string" ? parseDataFlag(flags, "Use a flat LinkedIn campaign changes object") : buildLinkedInCampaignUpdatePayload(flags);
+  return client.patch(`/manage/linkedin/campaigns/${id}${qs}`, body);
+}
+async function listLinkedInAdGroups(client, _args, flags) {
+  validateFlags(flags, AD_GROUP_LIST_FLAGS3, "manage linkedin ad-groups list");
+  const qs = buildLinkedInListQuery(flags, ["campaign-ids", "ad-group-ids"]);
+  return client.get(`/manage/linkedin/ad-groups${qs}`);
+}
+async function getLinkedInAdGroup(client, args, flags) {
+  validateFlags(flags, [], "manage linkedin ad-groups <id>");
+  const id = requireArg(args, 0, "ad-group-id", "Run: adkit manage linkedin ad-groups <ad-group-id>");
+  const qs = buildLinkedInReadQuery(flags);
+  return client.get(`/manage/linkedin/ad-groups/${id}${qs}`);
+}
+async function createLinkedInAdGroup(client, _args, flags) {
+  validateFlags(flags, AD_GROUP_CREATE_FLAGS2, "manage linkedin ad-groups create");
+  const qs = buildLinkedInMutationQuery(flags);
+  if (typeof flags.data === "string") {
+    const body2 = parseDataFlag(flags, 'Use { "adGroups": [...] } for LinkedIn ad group create');
+    return client.post(`/manage/linkedin/ad-groups${qs}`, body2);
+  }
+  const body = { adGroups: [buildLinkedInAdGroupPayload(flags)] };
+  return client.post(`/manage/linkedin/ad-groups${qs}`, body);
+}
+async function updateLinkedInAdGroup(client, args, flags) {
+  validateFlags(flags, AD_GROUP_UPDATE_FLAGS2, "manage linkedin ad-groups update");
+  const id = requireArg(args, 0, "ad-group-id", "Run: adkit manage linkedin ad-groups update <ad-group-id> --status paused");
+  const qs = buildLinkedInMutationQuery(flags);
+  const body = typeof flags.data === "string" ? parseDataFlag(flags, "Use a flat LinkedIn ad group changes object") : buildLinkedInAdGroupUpdatePayload(flags);
+  return client.patch(`/manage/linkedin/ad-groups/${id}${qs}`, body);
+}
+async function listLinkedInAds(client, _args, flags) {
+  validateFlags(flags, AD_LIST_FLAGS3, "manage linkedin ads list");
+  const qs = buildLinkedInListQuery(flags, ["campaign-ids"]);
+  return client.get(`/manage/linkedin/ads${qs}`);
+}
+async function getLinkedInAd(client, args, flags) {
+  validateFlags(flags, [], "manage linkedin ads <id>");
+  const id = requireArg(args, 0, "ad-id", "Run: adkit manage linkedin ads <ad-id>");
+  const qs = buildLinkedInReadQuery(flags);
+  return client.get(`/manage/linkedin/ads/${id}${qs}`);
+}
+async function createLinkedInAd(client, _args, flags) {
+  validateFlags(flags, AD_CREATE_FLAGS2, "manage linkedin ads create");
+  const qs = buildLinkedInMutationQuery(flags);
+  if (typeof flags.data === "string") {
+    const body2 = parseDataFlag(flags, 'Use { "ads": [...] } for LinkedIn ad create');
+    return client.post(`/manage/linkedin/ads${qs}`, body2);
+  }
+  if (typeof flags["existing-post"] !== "string") throw new CliError("MISSING_FLAG", "A LinkedIn ad needs a creative or an existing post", `Inline ad: --data '{"ads":[{"adGroupId":"...","creative":{"media":[{"role":"image","id":"urn:li:image:..."}]}}]}'. Reference ad: --existing-post <share/ugcPost URN>`);
+  const body = { ads: [buildLinkedInAdPayload(flags)] };
+  return client.post(`/manage/linkedin/ads${qs}`, body);
+}
+async function updateLinkedInAd(client, args, flags) {
+  validateFlags(flags, AD_UPDATE_FLAGS2, "manage linkedin ads update");
+  const id = requireArg(args, 0, "ad-id", "Run: adkit manage linkedin ads update <ad-id> --status paused");
+  const qs = buildLinkedInMutationQuery(flags);
+  const body = typeof flags.data === "string" ? parseDataFlag(flags, "Use a flat LinkedIn ad changes object (name/status only)") : buildLinkedInAdUpdatePayload(flags);
+  return client.patch(`/manage/linkedin/ads/${id}${qs}`, body);
+}
+async function searchLinkedInTargeting(client, _args, flags) {
+  validateFlags(flags, TARGETING_SEARCH_FLAGS, "manage linkedin targeting-search");
+  const facet = requireFlag(flags, "facet", "Use jobTitles, seniorities, jobFunctions, industries, companySizes, companies, skills, interests, geoLocations, ageRanges, genders, or customAudiences");
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const query = typeof flags.query === "string" ? flags.query : void 0;
+  const limit = typeof flags.limit === "string" ? flags.limit : void 0;
+  const qs = queryString({ accountId, facet, query, limit });
+  return client.get(`/manage/linkedin/targeting-search${qs}`);
+}
+async function listLinkedInResults(client, _args, flags) {
+  validateFlags(flags, RESULTS_FLAGS2, "manage linkedin results");
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const level = requireFlag(flags, "level", "Use --level account, campaigns, ad-groups, or ads");
+  const query = queryString({
+    accountId,
+    level,
+    period: typeof flags.period === "string" ? flags.period : void 0,
+    fields: typeof flags.fields === "string" ? flags.fields : void 0,
+    from: typeof flags.from === "string" ? flags.from : void 0,
+    to: typeof flags.to === "string" ? flags.to : void 0,
+    breakdowns: typeof flags.breakdowns === "string" ? flags.breakdowns : void 0,
+    sort: typeof flags.sort === "string" ? flags.sort : void 0,
+    limit: typeof flags.limit === "string" ? flags.limit : void 0,
+    offset: typeof flags.offset === "string" ? flags.offset : void 0
+  });
+  return client.get(`/manage/linkedin/results${query}`);
+}
+function buildLinkedInListQuery(flags, filterKeys) {
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const campaignIds = filterKeys.includes("campaign-ids") && typeof flags["campaign-ids"] === "string" ? flags["campaign-ids"] : void 0;
+  const adGroupIds = filterKeys.includes("ad-group-ids") && typeof flags["ad-group-ids"] === "string" ? flags["ad-group-ids"] : void 0;
+  const limit = typeof flags.limit === "string" ? flags.limit : void 0;
+  const offset = typeof flags.offset === "string" ? flags.offset : void 0;
+  return queryString({ accountId, campaignIds, adGroupIds, limit, offset });
+}
+function buildLinkedInReadQuery(flags) {
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  return queryString({ accountId });
+}
+function buildLinkedInMutationQuery(flags) {
+  const accountId = typeof flags.account === "string" ? flags.account : void 0;
+  const publish = flags.publish === true ? "true" : void 0;
+  return queryString({ accountId, publish });
+}
+function buildLinkedInCampaignPayload(flags) {
+  const payload = {};
+  payload.name = requireFlag(flags, "name", 'Run: adkit manage linkedin campaigns create --name "Spring Sale"');
+  if (typeof flags.status === "string") payload.status = flags.status;
+  if (typeof flags["end-date"] === "string") payload.endDate = flags["end-date"];
+  const budget = buildLinkedInBudget(flags);
+  if (budget) payload.budget = budget;
+  if (budget?.lifetime !== void 0 && payload.endDate === void 0) throw new CliError("MISSING_FLAG", "A lifetime budget needs an end date", "Pass --end-date YYYY-MM-DD alongside --budget-lifetime");
+  return payload;
+}
+function buildLinkedInAdGroupPayload(flags) {
+  const payload = {};
+  payload.campaignId = requireFlag(flags, "campaign", 'Run: adkit manage linkedin ad-groups create --campaign <campaign-id> --name "US Broad"');
+  payload.name = requireFlag(flags, "name", 'Run: adkit manage linkedin ad-groups create --name "US Broad"');
+  const budget = buildLinkedInBudget(flags);
+  if (budget) payload.budget = budget;
+  if (typeof flags.objective === "string") payload.objective = flags.objective;
+  if (typeof flags.status === "string") payload.status = flags.status;
+  return payload;
+}
+function buildLinkedInAdPayload(flags) {
+  const payload = {};
+  payload.adGroupId = requireFlag(flags, "ad-group", "Run: adkit manage linkedin ads create --ad-group <ad-group-id> --existing-post <share/ugcPost URN>");
+  payload.existingPostId = requireFlag(flags, "existing-post", "Run: adkit manage linkedin ads create --ad-group <ad-group-id> --existing-post <share/ugcPost URN>");
+  if (typeof flags.name === "string") payload.name = flags.name;
+  if (typeof flags.status === "string") payload.status = flags.status;
+  return payload;
+}
+function buildLinkedInCampaignUpdatePayload(flags) {
+  const payload = {};
+  if (typeof flags.name === "string") payload.name = flags.name;
+  if (typeof flags.status === "string") payload.status = flags.status;
+  if (typeof flags["end-date"] === "string") payload.endDate = flags["end-date"];
+  const budget = buildLinkedInBudget(flags);
+  if (budget) payload.budget = budget;
+  if (budget?.lifetime !== void 0 && payload.endDate === void 0) throw new CliError("MISSING_FLAG", "A lifetime budget needs an end date", "Pass --end-date YYYY-MM-DD alongside --budget-lifetime");
+  return payload;
+}
+function buildLinkedInAdGroupUpdatePayload(flags) {
+  const payload = {};
+  if (typeof flags.name === "string") payload.name = flags.name;
+  if (typeof flags.status === "string") payload.status = flags.status;
+  if (typeof flags["start-date"] === "string") payload.startDate = flags["start-date"];
+  if (typeof flags["end-date"] === "string") payload.endDate = flags["end-date"];
+  const budget = buildLinkedInBudget(flags);
+  if (budget) payload.budget = budget;
+  return payload;
+}
+function buildLinkedInAdUpdatePayload(flags) {
+  const payload = {};
+  if (typeof flags.name === "string") payload.name = flags.name;
+  if (typeof flags.status === "string") payload.status = flags.status;
+  return payload;
+}
+function buildLinkedInBudget(flags) {
+  const daily = readNumberFlag3(flags, "budget-daily");
+  const lifetime = readNumberFlag3(flags, "budget-lifetime");
+  if (daily === void 0 && lifetime === void 0) return void 0;
+  if (daily !== void 0 && lifetime !== void 0) throw new CliError("INVALID_VALUE", "Use either --budget-daily or --budget-lifetime", "LinkedIn accepts one budget mode at a time");
+  return daily !== void 0 ? { daily } : { lifetime };
+}
+function readNumberFlag3(flags, key) {
+  const value = flags[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new CliError("INVALID_VALUE", `Use one --${key} value`, `Run: adkit manage linkedin --help`);
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new CliError("INVALID_VALUE", `Invalid number for --${key}: ${value}`, `Use a numeric value for --${key}`);
+  return parsed;
+}
+function readSingleFlagValue3(flags, key, duplicateHint) {
+  const value = flags[key];
+  if (Array.isArray(value)) {
+    if (value.length > 1) throw new CliError("INVALID_VALUE", `Use one --${key} value`, duplicateHint);
+    return typeof value[0] === "string" ? value[0] : void 0;
+  }
+  return typeof value === "string" ? value : void 0;
+}
+function inferLinkedInMediaContentType(filename) {
+  const extension = extname3(filename).toLowerCase();
+  if (extension === ".jpg" || extension === ".jpeg") return "image/jpeg";
+  if (extension === ".png") return "image/png";
+  if (extension === ".gif") return "image/gif";
+  if (extension === ".mp4") return "video/mp4";
+  if (extension === ".mov") return "video/quicktime";
+  return void 0;
+}
+function buildLinkedInMediaUploadSource(flags) {
+  const filePath = readSingleFlagValue3(flags, "file", "Use one media source per command, or switch to --data for batch upload");
+  const url = readSingleFlagValue3(flags, "url", "Use one media source per command, or switch to --data for batch upload");
+  const base64 = readSingleFlagValue3(flags, "base64", "Use one media source per command, or switch to --data for batch upload");
+  const adkitMediaId = readSingleFlagValue3(flags, "adkit-media", "Use one media source per command, or switch to --data for batch upload");
+  const temporaryUploadId = readSingleFlagValue3(flags, "temporary-upload", "Use one media source per command, or switch to --data for batch upload");
+  const sourceCount = [filePath, url, base64, adkitMediaId, temporaryUploadId].filter(Boolean).length;
+  if (sourceCount === 0) throw new CliError("MISSING_FLAG", "Missing required media source flag", "Use --file, --url, --base64, --adkit-media, or --temporary-upload");
+  if (sourceCount > 1) throw new CliError("INVALID_VALUE", "Use exactly one media source flag", "Use one of --file, --url, --base64, --adkit-media, or --temporary-upload");
+  const filename = readSingleFlagValue3(flags, "filename", "Use one --filename value");
+  const contentType = readSingleFlagValue3(flags, "content-type", "Use one --content-type value");
+  const name = readSingleFlagValue3(flags, "name", "Use one --name value");
+  if (filePath) {
+    const resolvedPath = resolve3(filePath);
+    const resolvedFilename = filename ?? basename3(resolvedPath);
+    const resolvedContentType = contentType ?? inferLinkedInMediaContentType(resolvedFilename);
+    const data = readFileSync4(resolvedPath).toString("base64");
+    const source2 = { source: "base64", data, filename: resolvedFilename };
+    if (resolvedContentType) source2.contentType = resolvedContentType;
+    if (name) source2.name = name;
+    return source2;
+  }
+  if (url) {
+    const source2 = { source: "url", url };
+    if (filename) source2.filename = filename;
+    if (contentType) source2.contentType = contentType;
+    if (name) source2.name = name;
+    return source2;
+  }
+  if (base64) {
+    if (!filename) throw new CliError("MISSING_FLAG", "Missing required flag: `--filename`", "Base64 uploads need a filename so LinkedIn can infer media type");
+    const source2 = { source: "base64", data: base64, filename };
+    if (contentType) source2.contentType = contentType;
+    if (name) source2.name = name;
+    return source2;
+  }
+  if (adkitMediaId) {
+    const source2 = { source: "adkit_media", mediaId: adkitMediaId };
+    if (name) source2.name = name;
+    return source2;
+  }
+  if (!temporaryUploadId) throw new CliError("MISSING_FLAG", "Missing required flag: `--temporary-upload`", "Use --temporary-upload <upload-id>");
+  const source = { source: "temporary_upload", uploadId: temporaryUploadId };
+  if (name) source.name = name;
+  return source;
+}
 
 // src/commands/status.ts
 function isStatusResponse(value) {
@@ -3659,8 +3952,8 @@ async function pollMedia(client, mediaIds, fields) {
       if (!currentMedia || typeof currentMedia.status !== "string") throw new CliError("SERVER_ERROR", `Invalid media response while polling ${id}`);
       media = currentMedia;
       if (currentMedia.status === "completed" || currentMedia.status === "failed") break;
-      await new Promise((resolve3) => {
-        setTimeout(resolve3, 2e3);
+      await new Promise((resolve4) => {
+        setTimeout(resolve4, 2e3);
       });
     }
     results.push(media);
@@ -3917,14 +4210,14 @@ function toGoogleSearchTermDisplayRows(row) {
 import { createRequire } from "node:module";
 
 // src/update-check.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
 import { join as join2 } from "node:path";
 var CACHE_PATH = join2(CONFIG_DIR, "update-check.json");
 var FETCH_TIMEOUT_MS = 3e3;
 var REGISTRY_URL = "https://registry.npmjs.org/@adkit/cli/latest";
 function readCache() {
   try {
-    const raw = readFileSync4(CACHE_PATH, "utf-8");
+    const raw = readFileSync5(CACHE_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return void 0;
     const cache = parsed;
@@ -4123,6 +4416,7 @@ var DEFAULT_BASE_URL = "https://app.adkit.so/api/v1";
 var GOOGLE_NUMERIC_ID_PATTERN = /^\d+$/;
 var GOOGLE_RESULTS_LEVEL_ACTIONS = /* @__PURE__ */ new Set(["campaigns", "ad-groups", "ads"]);
 var TIKTOK_NUMERIC_ID_PATTERN = /^\d+$/;
+var LINKEDIN_ID_PATTERN = /[\d:_]/;
 var USAGE = `
 Usage: adkit <command> [options]
 
@@ -4573,7 +4867,7 @@ Flags:
   --from <date>       Start date, YYYY-MM-DD
   --to <date>         End date, YYYY-MM-DD
   --fields <list>     Normalized fields, e.g. spend, impressions, clicks, conversionEvents, etc
-  --conversion-event-keys <list> purchase,lead or all
+  --conversion-event-keys <list> purchase,lead,messaging_conversation_started or all
   --attribution-window <w>  1d_click, 7d_click, 1d_view, 7d_click_1d_view, 28d_click_1d_view
   --breakdowns <list> day, week, month, age, gender, country, region, device_platform, publisher_platform, platform_position, impression_device
   --confirm           Required with --period maximum plus any breakdown
@@ -4596,6 +4890,8 @@ Examples:
   adkit manage meta results ads --period maximum --breakdowns country --confirm
   # Conversion data for a campaign
   adkit manage meta results --campaign-ids 123 --conversion-event-keys purchase,lead
+  # Messenger conversations for click-to-Messenger campaigns
+  adkit manage meta results --campaign-ids 123 --conversion-event-keys messaging_conversation_started
   # Raw API response with custom metrics
   adkit manage meta results --campaign-ids 123 --raw --fields spend,impressions,conversionEvents`.trim();
 var CREATIVE_HELP = `adkit manage meta creatives \u2014 Meta ad creatives
@@ -5649,6 +5945,177 @@ Note:
 
 Example:
   adkit manage tiktok results --level campaigns --fields spend,impressions,clicks --breakdowns day --from 2026-05-01 --to 2026-05-15`.trim(),
+  "linkedin campaigns": `adkit manage linkedin campaigns \u2014 LinkedIn campaigns (LinkedIn "Campaign Groups")
+
+  list                List campaigns
+  create              Create a campaign draft
+  update <id>         Update a campaign (rename, pause/resume, budget)
+  <id>                View campaign details
+
+Naming note:
+  AdKit "campaigns" are LinkedIn "Campaign Groups". Objective, daily budgets, and targeting live on ad-groups; this tier takes lifetime budgets only.
+  IDs copied from Campaign Manager's "Campaigns" tab are AdKit ad-group IDs, not campaign IDs.
+
+Flags:
+${FLAG.account}
+${FLAG.publish}
+${FLAG.data}
+  --limit <n>         Max rows for list
+  --offset <n>        Row offset for list
+  --campaign-ids <ids> Comma-separated campaign IDs for filtered reads
+  --name <name>       Campaign name
+  --status <s>        create: active or draft (defaults to draft). update: active, paused, or archived
+  --budget-lifetime <n> Lifetime budget in account currency
+  --end-date <date>   YYYY-MM-DD; required with --budget-lifetime
+
+Notes:
+  This tier takes lifetime budgets only; a daily budget here returns a 500. Set daily budgets on ad-groups.
+  A live campaign can never go back to draft.
+
+Examples:
+  adkit manage linkedin campaigns list --account 512345678
+  adkit manage linkedin campaigns create --name "Spring Sale" --budget-lifetime 500 --end-date 2026-08-31
+  adkit manage linkedin campaigns update 628940516 --account 512345678 --status paused
+  adkit manage linkedin campaigns 628940516 --account 512345678`.trim(),
+  "linkedin ad-groups": `adkit manage linkedin ad-groups \u2014 LinkedIn ad groups (LinkedIn "Campaigns"/"Ad sets")
+
+  list                List ad groups
+  create              Create an ad group draft
+  update <id>         Update an ad group (rename, pause/resume, budget, dates, targeting)
+  <id>                View ad group details
+
+Naming note:
+  AdKit "ad-groups" are what Campaign Manager now calls "Campaigns" (formerly "Ad sets"). Objective, budget, and targeting live here.
+  IDs copied from Campaign Manager's "Campaigns" tab are AdKit ad-group IDs.
+
+Flags:
+${FLAG.account}
+${FLAG.publish}
+${FLAG.data}
+  --limit <n>         Max rows for list
+  --offset <n>        Row offset for list
+  --campaign-ids <ids> Comma-separated parent campaign IDs for filtered reads
+  --ad-group-ids <ids> Comma-separated ad group IDs for filtered reads
+  --campaign <id>     Parent campaign ID (create only)
+  --name <name>       Ad group name
+  --objective <type>  brand_awareness, engagement, website_visits, video_views, website_conversions
+  --status <s>        create: active or draft (defaults to draft). update: active, paused, or archived
+  --budget-daily <n>  Daily budget in account currency
+  --budget-lifetime <n> Lifetime budget in account currency
+  --start-date <date> YYYY-MM-DD (update only)
+  --end-date <date>   YYYY-MM-DD (update only)
+
+Targeting (--data only):
+  targeting is nested: { geoLocations: { include: [{ type: "country", code }] }, audience: { <facet>: { include?: [ids], exclude?: [ids] } } }.
+  Values are bare IDs \u2014 use "adkit manage linkedin targeting-search" to find them.
+  Facets: jobTitles, seniorities, jobFunctions, industries, companySizes, companies, skills, interests, customAudiences, ageRanges, genders.
+  ageRanges/genders are include-only (LinkedIn rejects them in exclude): ageRanges take tuples like (25,34), genders take FEMALE/MALE.
+  customAudiences goes inside targeting.audience (never top-level): pass the segment ID/URN. Matched Audiences are created in Campaign Manager, but you list them with "adkit manage linkedin targeting-search --facet customAudiences". Choose a language via platformOverrides.locale.
+
+Notes:
+  A live ad group can never go back to draft. targeting on update is a full replace (send the whole targeting object via --data).
+
+Examples:
+  adkit manage linkedin ad-groups create --campaign 628940516 --name "US Broad" --budget-daily 50 --objective website_visits
+  adkit manage linkedin ad-groups update 361387516 --account 512345678 --status paused
+  adkit manage linkedin ad-groups create --data '{"adGroups":[{"campaignId":"628940516","name":"US Senior Eng","budget":{"daily":50},"targeting":{"geoLocations":{"include":[{"type":"country","code":"103644278"}]},"audience":{"seniorities":{"include":["6"]},"customAudiences":{"include":["123456"]}}}}]}'`.trim(),
+  "linkedin ads": `adkit manage linkedin ads \u2014 LinkedIn ads
+
+  list                List ads
+  create              Create an ad draft
+  update <id>         Update an ad (rename, pause/resume) \u2014 name and status only
+  <id>                View ad details
+
+Flags:
+${FLAG.account}
+${FLAG.publish}
+${FLAG.data}
+  --limit <n>         Max rows for list
+  --offset <n>        Row offset for list
+  --campaign-ids <ids> Comma-separated parent ad-group IDs for filtered reads
+  --ad-group <id>     Parent ad group ID (create only)
+  --existing-post <urn> Reference an existing share/ugcPost URN (create only)
+  --name <name>       Ad name
+  --status <s>        create: active or draft (defaults to draft). update: active, paused, or archived
+
+Create:
+  Inline ad: pass --data with a creative \u2014 keys are primaryTexts, headlines, media, url, cta. creative.media needs at least one { role: "image"|"video", id: "urn:li:image:..." } entry.
+  Reference ad: pass --existing-post <share/ugcPost URN>; omit creative entirely (its text/url/media are ignored).
+  creative.cta is the button label \u2014 one of: apply, download, view_quote, learn_more, sign_up, subscribe, register, join, attend, request_demo, see_more, buy_now, shop_now. It needs creative.url and cannot be combined with existing-post.
+  Media IDs are the opaque URNs returned by "adkit manage linkedin media upload".
+
+Update:
+  Rename + pause/resume only \u2014 creative content and the parent ad-group are locked after create.
+  Pausing an ACTIVE ad only works once LinkedIn review has APPROVED the creative; a still-in-review ad rejects the pause. A live ad can never go back to draft.
+
+Examples:
+  adkit manage linkedin ads list --account 512345678
+  adkit manage linkedin ads create --data '{"ads":[{"adGroupId":"361387516","creative":{"media":[{"role":"image","id":"urn:li:image:C123"}]}}]}'
+  adkit manage linkedin ads create --ad-group 361387516 --existing-post urn:li:share:123456
+  adkit manage linkedin ads update 361387516 --account 512345678 --status paused`.trim(),
+  "linkedin media": `adkit manage linkedin media \u2014 Upload creative media and fetch by URN
+
+  upload              Upload an image or video and return a LinkedIn media URN
+  <urn>               Fetch a single media asset by URN
+
+Flags:
+  --file <path>       Local image/video file
+  --url <url>         Public image/video URL
+  --base64 <data>     Base64 image/video data
+  --adkit-media <id>  Existing AdKit Studio media ID
+  --temporary-upload <id> Temporary upload ID from the upload URL helper
+  --filename <name>   Required with --base64, optional with --url
+  --content-type <t>  image/jpeg, image/png, image/gif, video/mp4, or video/quicktime
+  --name <name>       Media asset name
+${FLAG.account}
+  --data <json>       Batch body: {"assets":[...]}
+
+Note:
+  Media IDs are opaque URNs (e.g. urn:li:image:C123) returned by upload. Pass them into ad creatives via --data.
+
+Examples:
+  adkit manage linkedin media upload --url https://example.com/hero.png --filename hero.png --account 512345678
+  adkit manage linkedin media upload --adkit-media media_123 --account 512345678
+  adkit manage linkedin media urn:li:image:C123 --account 512345678`.trim(),
+  "linkedin targeting-search": `adkit manage linkedin targeting-search \u2014 Look up bare targeting IDs
+
+  search              Search a facet for the bare IDs used in ad group targeting
+
+Flags:
+  --facet <facet>     jobTitles, seniorities, jobFunctions, industries, companySizes, companies, skills, interests, geoLocations, ageRanges, genders, customAudiences
+  --query <text>      Search text; optional for the enum facets (seniorities, jobFunctions, companySizes, ageRanges, genders, customAudiences)
+  --limit <n>         Max results
+  --account <id>      LinkedIn ad account; required when several accounts are connected
+
+Note:
+  Returned IDs are bare \u2014 feed them into ad-group targeting via --data.
+  Matched Audiences are created in Campaign Manager, but you list them here with --facet customAudiences.
+
+Examples:
+  adkit manage linkedin targeting-search --facet jobTitles --query engineer
+  adkit manage linkedin targeting-search --facet seniorities
+  adkit manage linkedin targeting-search --facet customAudiences`.trim(),
+  "linkedin results": `adkit manage linkedin results \u2014 LinkedIn performance reporting
+
+  list                List reporting rows
+
+Flags:
+${FLAG.account}
+  --level <level>     Required: account, campaigns, ad-groups, ads
+  --period <p>        Rolling window, e.g. 14d (default: 14d); or use --from/--to
+  --fields <csv>      Normalized fields, e.g. cost,impressions,clicks
+  --breakdowns <csv>  Row breakdowns, e.g. day
+  --from <date>       YYYY-MM-DD
+  --to <date>         YYYY-MM-DD
+  --sort <field>      Optional normalized sort field, e.g. cost (default: cost). Rows always sort descending.
+  --limit <n>         Max rows
+  --offset <n>        Row offset
+
+Note:
+  --level is required. Results come back as a flat { results, currency, timezone, period, ... } envelope. Spend is reported as the canonical "cost" field. Sort is descending-only.
+
+Example:
+  adkit manage linkedin results --level campaigns --fields cost,impressions,clicks --breakdowns day --from 2026-05-01 --to 2026-05-15`.trim(),
   "reddit accounts": `adkit manage reddit accounts \u2014 Reddit Ads accounts
 
   list                List connected Reddit ad accounts
@@ -5710,7 +6177,7 @@ Platforms:
   tiktok              TikTok Ads
   reddit              Reddit Ads
   x                   X Ads raw API access
-  linkedin            LinkedIn Ads (account discovery + raw API access)
+  linkedin            LinkedIn Ads (campaigns, ad groups, ads, targeting, results)
   drafts              Manage drafts across platforms
   platform-api-requests  Send raw API requests (escape hatch)
 
@@ -5806,16 +6273,26 @@ Examples:
   linkedin: `adkit manage linkedin \u2014 LinkedIn Ads management
 
 Entity groups:
-  accounts available  List LinkedIn ad accounts discoverable from connected workspace logins
+  accounts            Discover LinkedIn ad accounts (available)
+  media               Upload creative and fetch media by URN
+  campaigns           Manage campaigns (LinkedIn "Campaign Groups")
+  ad-groups           Manage ad groups (LinkedIn "Campaigns"/"Ad sets" \u2014 objective, budget, targeting)
+  ads                 Manage ads
+  targeting-search    Look up bare targeting IDs by facet
+  results             Performance metrics
 
-Account discovery currently supports "available" only \u2014 connect/disconnect/list are not exposed yet.
-First-class LinkedIn campaign/ad reads and writes are not enabled yet.
-${rawPlatformCommandLine("linkedin")}
+Naming note (Campaign Manager renamed things in Oct 2025):
+  AdKit "campaigns"  = LinkedIn "Campaign Groups"
+  AdKit "ad-groups"  = LinkedIn "Campaigns" / "Ad sets" \u2014 this is where objective, budget, and targeting live.
+  IDs copied from Campaign Manager's "Campaigns" tab are AdKit ad-group IDs.
 
 General flags:
 ${FLAG.account}
+${FLAG.publish}
+${FLAG.data}
 
-Run adkit manage linkedin accounts available to discover ad accounts.`.trim(),
+${rawPlatformCommandLine("linkedin")}
+Run adkit manage linkedin <group> --help for details.`.trim(),
   drafts: `adkit manage drafts \u2014 Manage drafts
 
   list                List all drafts
@@ -7588,8 +8065,104 @@ async function main() {
                 throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin accounts ${action}`, "Available: available.");
             }
             break;
+          case "media": {
+            if (!action) {
+              showHelp("linkedin media", flags.help === "full");
+              return;
+            }
+            switch (action) {
+              case "upload":
+                data = await uploadLinkedInMedia(client, restArgs, flags);
+                break;
+              case "get":
+                data = await getLinkedInMedia(client, restArgs, flags);
+                break;
+              default:
+                if (LINKEDIN_ID_PATTERN.test(action)) data = await getLinkedInMedia(client, [action], flags);
+                else throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin media ${action}`, "Available: upload, get");
+            }
+            break;
+          }
+          case "campaigns": {
+            if (!action) {
+              showHelp("linkedin campaigns", flags.help === "full");
+              return;
+            }
+            switch (action) {
+              case "list":
+                data = await listLinkedInCampaigns(client, restArgs, flags);
+                emptyHint = "No LinkedIn campaigns found for this account.";
+                break;
+              case "create":
+                data = await createLinkedInCampaign(client, restArgs, flags);
+                break;
+              case "update":
+                data = await updateLinkedInCampaign(client, restArgs, flags);
+                break;
+              default:
+                if (LINKEDIN_ID_PATTERN.test(action)) data = await getLinkedInCampaign(client, [action], flags);
+                else throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin campaigns ${action}`, "Available: list, create, update");
+            }
+            break;
+          }
+          case "ad-groups": {
+            if (!action) {
+              showHelp("linkedin ad-groups", flags.help === "full");
+              return;
+            }
+            switch (action) {
+              case "list":
+                data = await listLinkedInAdGroups(client, restArgs, flags);
+                emptyHint = "No LinkedIn ad groups found for this account.";
+                break;
+              case "create":
+                data = await createLinkedInAdGroup(client, restArgs, flags);
+                break;
+              case "update":
+                data = await updateLinkedInAdGroup(client, restArgs, flags);
+                break;
+              default:
+                if (LINKEDIN_ID_PATTERN.test(action)) data = await getLinkedInAdGroup(client, [action], flags);
+                else throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin ad-groups ${action}`, "Available: list, create, update");
+            }
+            break;
+          }
+          case "ads": {
+            if (!action) {
+              showHelp("linkedin ads", flags.help === "full");
+              return;
+            }
+            switch (action) {
+              case "list":
+                data = await listLinkedInAds(client, restArgs, flags);
+                emptyHint = "No LinkedIn ads found for this account.";
+                break;
+              case "create":
+                data = await createLinkedInAd(client, restArgs, flags);
+                break;
+              case "update":
+                data = await updateLinkedInAd(client, restArgs, flags);
+                break;
+              default:
+                if (LINKEDIN_ID_PATTERN.test(action)) data = await getLinkedInAd(client, [action], flags);
+                else throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin ads ${action}`, "Available: list, create, update");
+            }
+            break;
+          }
+          case "targeting-search": {
+            if (action && action !== "search") throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin targeting-search ${action}`, "Available: search");
+            data = await searchLinkedInTargeting(client, restArgs, flags);
+            emptyHint = "No LinkedIn targeting entities matched this facet/query.";
+            break;
+          }
+          case "results": {
+            if (action && action !== "list") throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin results ${action}`, "Available: list");
+            data = await listLinkedInResults(client, restArgs, flags);
+            emptyHint = "No LinkedIn result rows found for the selected date range.";
+            break;
+          }
           default:
-            throw new CliError("UNKNOWN_COMMAND", `Unknown entity: linkedin ${entity}`, "Available: accounts, platform-api-requests");
+            throw new CliError("UNKNOWN_COMMAND", `Unknown entity: linkedin ${entity}`, "Available: accounts, media, campaigns, ad-groups, ads, targeting-search, results, platform-api-requests");
         }
       } else if (platform2 === "x") throw new CliError("UNKNOWN_COMMAND", `Unknown entity: x ${entity}`, "Available: platform-api-requests");
       else throw new CliError("UNKNOWN_COMMAND", "Unknown platform", "Available: meta, google, tiktok, reddit, x, linkedin, drafts, platform-api-requests");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adkit/cli",
-  "version": "1.12.28",
+  "version": "1.12.30",
   "description": "The Ads CLI for AI agents — manage Meta & Google ad campaigns, browse the ad library, and generate creatives from your terminal.",
   "keywords": [
     "ads cli",