@adkit/cli 1.13.26 → 1.13.27

package/README.md

@@ -44,7 +44,7 @@ adkit projects current
 Browse competitor ads and advertisers tracked by AdKit.
 
 ```bash
-adkit library advertisers list --search "notion" --platform meta
+adkit library advertisers search "notion" --platform meta
 adkit library advertisers <id>
 adkit library advertisers similar --industry saas
 adkit library ads list --advertiser <id>

package/dist/cli.js

@@ -3519,10 +3519,25 @@ var AD_GROUP_UPDATE_FLAGS2 = ["name", "status", "budget-daily", "budget-lifetime
 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 listLinkedInAccounts(client, _args, flags) {
+  validateFlags(flags, [], "manage linkedin accounts list");
+  return client.get("/manage/linkedin/accounts");
+}
 async function listLinkedInAvailableAccounts(client, _args, flags) {
   validateFlags(flags, [], "manage linkedin accounts available");
   return client.get("/manage/linkedin/accounts/available");
 }
+async function connectLinkedInAccount(client, args, flags) {
+  validateFlags(flags, ["integration"], "manage linkedin accounts connect");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage linkedin accounts connect <account-id>");
+  const integrationId = typeof flags.integration === "string" ? flags.integration : void 0;
+  return client.post("/manage/linkedin/accounts/connect", { accountId, ...integrationId ? { integrationId } : {} });
+}
+async function disconnectLinkedInAccount(client, args, flags) {
+  validateFlags(flags, [], "manage linkedin accounts disconnect");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage linkedin accounts disconnect <account-id>");
+  return client.delete(`/manage/linkedin/accounts/${accountId}`);
+}
 async function uploadLinkedInMedia(client, _args, flags) {
   validateFlags(flags, MEDIA_UPLOAD_FLAGS3, "manage linkedin media upload");
   if (typeof flags.data === "string") {
@@ -3811,13 +3826,170 @@ function buildLinkedInMediaUploadSource(flags) {
   return source;
 }
 
+// src/commands/x.ts
+var CAMPAIGN_LIST_FLAGS4 = ["campaign-ids", "status", "limit", "offset"];
+var AD_GROUP_LIST_FLAGS4 = ["campaign-ids", "ad-group-ids", "status", "limit", "offset"];
+var AD_LIST_FLAGS4 = ["campaign-ids", "ad-group-ids", "ad-ids", "status", "limit", "offset"];
+var RESULTS_FLAGS3 = ["level", "from", "to", "fields", "breakdowns", "campaign-ids", "ad-group-ids", "ad-ids", "sort", "sort-direction", "limit", "offset", "raw"];
+async function listXAccounts(client, _args, flags) {
+  validateFlags(flags, [], "manage x accounts list");
+  return client.get("/manage/x/accounts");
+}
+async function listXAvailableAccounts(client, _args, flags) {
+  validateFlags(flags, [], "manage x accounts available");
+  return client.get("/manage/x/accounts/available");
+}
+async function connectXAccount(client, args, flags) {
+  validateFlags(flags, ["integration"], "manage x accounts connect");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage x accounts connect <account-id>");
+  const integrationId = typeof flags.integration === "string" ? flags.integration : void 0;
+  return client.post("/manage/x/accounts/connect", { accountId, ...integrationId ? { integrationId } : {} });
+}
+async function disconnectXAccount(client, args, flags) {
+  validateFlags(flags, [], "manage x accounts disconnect");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage x accounts disconnect <account-id>");
+  return client.delete(`/manage/x/accounts/${accountId}`);
+}
+async function listXProfiles(client, args, flags) {
+  validateFlags(flags, [], "manage x accounts <account-id> profiles");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage x accounts <account-id> profiles");
+  return client.get(`/manage/x/accounts/${accountId}/profiles`);
+}
+async function listXPixels(client, args, flags) {
+  validateFlags(flags, [], "manage x accounts <account-id> pixels");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage x accounts <account-id> pixels");
+  return client.get(`/manage/x/accounts/${accountId}/pixels`);
+}
+async function updateXAccount(client, args, flags) {
+  validateFlags(flags, ["default-profile", "default-pixel"], "manage x accounts <account-id> update");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage x accounts <account-id> update --default-profile <profile-id>");
+  if (typeof flags.data === "string") {
+    const body = parseDataFlag(flags, 'Use { "defaultProfileId": "...", "defaultPixelId": "..." }');
+    return client.patch(`/manage/x/accounts/${accountId}`, body);
+  }
+  const defaultProfileId = typeof flags["default-profile"] === "string" ? flags["default-profile"] : void 0;
+  const defaultPixelId = typeof flags["default-pixel"] === "string" ? flags["default-pixel"] : void 0;
+  if (!defaultProfileId && !defaultPixelId) throw new CliError("MISSING_FLAG", "Nothing to update", "Pass --default-profile, --default-pixel, or --data");
+  return client.patch(`/manage/x/accounts/${accountId}`, {
+    ...defaultProfileId ? { defaultProfileId } : {},
+    ...defaultPixelId ? { defaultPixelId } : {}
+  });
+}
+async function listXCampaigns(client, _args, flags) {
+  validateXReadFlags(flags, CAMPAIGN_LIST_FLAGS4, "manage x campaigns list");
+  const query = buildXListQuery(flags, ["campaign-ids"]);
+  return client.get(`/manage/x/campaigns${query}`);
+}
+async function getXCampaign(client, args, flags) {
+  validateXReadFlags(flags, [], "manage x campaigns get");
+  const campaignId = requireArg(args, 0, "campaign-id", "Run: adkit manage x campaigns get <campaign-id>");
+  const query = queryString({ accountId: typeof flags.account === "string" ? flags.account : void 0 });
+  return client.get(`/manage/x/campaigns/${campaignId}${query}`);
+}
+async function listXAdGroups(client, _args, flags) {
+  validateXReadFlags(flags, AD_GROUP_LIST_FLAGS4, "manage x ad-groups list");
+  const query = buildXListQuery(flags, ["campaign-ids", "ad-group-ids"]);
+  return client.get(`/manage/x/ad-groups${query}`);
+}
+async function getXAdGroup(client, args, flags) {
+  validateXReadFlags(flags, [], "manage x ad-groups get");
+  const adGroupId = requireArg(args, 0, "ad-group-id", "Run: adkit manage x ad-groups get <ad-group-id>");
+  const query = queryString({ accountId: typeof flags.account === "string" ? flags.account : void 0 });
+  return client.get(`/manage/x/ad-groups/${adGroupId}${query}`);
+}
+async function listXAds(client, _args, flags) {
+  validateXReadFlags(flags, AD_LIST_FLAGS4, "manage x ads list");
+  const query = buildXListQuery(flags, ["campaign-ids", "ad-group-ids", "ad-ids"]);
+  return client.get(`/manage/x/ads${query}`);
+}
+async function getXAd(client, args, flags) {
+  validateXReadFlags(flags, [], "manage x ads get");
+  const adId = requireArg(args, 0, "ad-id", "Run: adkit manage x ads get <ad-id>");
+  const query = queryString({ accountId: typeof flags.account === "string" ? flags.account : void 0 });
+  return client.get(`/manage/x/ads/${adId}${query}`);
+}
+async function listXResults(client, _args, flags) {
+  validateXReadFlags(flags, RESULTS_FLAGS3, "manage x results");
+  const level = requireFlag(flags, "level", "Use --level campaigns, ad-groups, or ads");
+  const from = requireFlag(flags, "from", "Use --from YYYY-MM-DD with --to");
+  const to = requireFlag(flags, "to", "Use --to YYYY-MM-DD with --from");
+  const raw = flags.raw === true ? "true" : typeof flags.raw === "string" ? flags.raw : void 0;
+  const query = queryString({
+    accountId: typeof flags.account === "string" ? flags.account : void 0,
+    level,
+    from,
+    to,
+    fields: typeof flags.fields === "string" ? flags.fields : void 0,
+    breakdowns: typeof flags.breakdowns === "string" ? flags.breakdowns : void 0,
+    campaignIds: typeof flags["campaign-ids"] === "string" ? flags["campaign-ids"] : void 0,
+    adGroupIds: typeof flags["ad-group-ids"] === "string" ? flags["ad-group-ids"] : void 0,
+    adIds: typeof flags["ad-ids"] === "string" ? flags["ad-ids"] : void 0,
+    sort: typeof flags.sort === "string" ? flags.sort : void 0,
+    sortDirection: typeof flags["sort-direction"] === "string" ? flags["sort-direction"] : void 0,
+    limit: typeof flags.limit === "string" ? flags.limit : void 0,
+    offset: typeof flags.offset === "string" ? flags.offset : void 0,
+    raw
+  });
+  return client.get(`/manage/x/results${query}`);
+}
+function buildXListQuery(flags, filterKeys) {
+  return queryString({
+    accountId: typeof flags.account === "string" ? flags.account : void 0,
+    campaignIds: filterKeys.includes("campaign-ids") && typeof flags["campaign-ids"] === "string" ? flags["campaign-ids"] : void 0,
+    adGroupIds: filterKeys.includes("ad-group-ids") && typeof flags["ad-group-ids"] === "string" ? flags["ad-group-ids"] : void 0,
+    adIds: filterKeys.includes("ad-ids") && typeof flags["ad-ids"] === "string" ? flags["ad-ids"] : void 0,
+    status: typeof flags.status === "string" ? flags.status : void 0,
+    limit: typeof flags.limit === "string" ? flags.limit : void 0,
+    offset: typeof flags.offset === "string" ? flags.offset : void 0
+  });
+}
+function validateXReadFlags(flags, allowed, command) {
+  const permitted = /* @__PURE__ */ new Set(["account", "json", "project", ...allowed]);
+  const unsupported = Object.keys(flags).filter((flag) => !permitted.has(flag));
+  if (!unsupported.length) return;
+  const renderedFlags = unsupported.map((flag) => `--${flag}`).join(", ");
+  throw new CliError("UNKNOWN_FLAG", `Unknown flag${unsupported.length > 1 ? "s" : ""}: ${renderedFlags}`, `Run: adkit ${command} --help`);
+}
+
 // src/commands/microsoft.ts
+async function listMicrosoftAccounts(client, _args, flags) {
+  validateFlags(flags, [], "manage microsoft accounts list");
+  return client.get("/manage/microsoft/accounts");
+}
 async function listMicrosoftAvailableAccounts(client, _args, flags) {
   validateFlags(flags, [], "manage microsoft accounts available");
   return client.get("/manage/microsoft/accounts/available");
 }
+async function connectMicrosoftAccount(client, args, flags) {
+  validateFlags(flags, ["integration"], "manage microsoft accounts connect");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage microsoft accounts connect <account-id>");
+  const integrationId = typeof flags.integration === "string" ? flags.integration : void 0;
+  return client.post("/manage/microsoft/accounts/connect", { accountId, ...integrationId ? { integrationId } : {} });
+}
+async function disconnectMicrosoftAccount(client, args, flags) {
+  validateFlags(flags, [], "manage microsoft accounts disconnect");
+  const accountId = requireArg(args, 0, "account-id", "Run: adkit manage microsoft accounts disconnect <account-id>");
+  return client.delete(`/manage/microsoft/accounts/${accountId}`);
+}
 
 // src/commands/status.ts
+var STATUS_PLATFORMS = [
+  ["meta", "Meta"],
+  ["google", "Google"],
+  ["tiktok", "TikTok"],
+  ["reddit", "Reddit"],
+  ["x", "X"],
+  ["linkedin", "LinkedIn"],
+  ["microsoft", "Microsoft"]
+];
+var DEFAULT_LABELS = {
+  identityId: "Identity",
+  identityType: "Identity type",
+  instagramUserId: "Instagram user",
+  pageId: "Page",
+  pixelId: "Pixel",
+  profileId: "Profile"
+};
 function isStatusResponse(value) {
   if (!value || typeof value !== "object") return false;
   if (!("connected" in value) || typeof value.connected !== "boolean") return false;
@@ -3831,28 +4003,32 @@ async function status(client, json) {
   if (!isStatusResponse(response)) throw new Error("Unexpected response from AdKit status");
   const data = response;
   if (json) {
-    console.log(JSON.stringify(data));
+    const serializedStatus = JSON.stringify(data);
+    console.log(serializedStatus);
     return;
   }
   const { project, platforms } = data;
   const lines = [];
   lines.push(`Project: ${project.name || "unnamed"} (${project.id})`);
   lines.push("");
-  if (platforms.meta.connected) {
-    lines.push("Meta: connected");
-    for (const a of platforms.meta.accounts) {
-      lines.push(`  ${a.id} \u2014 ${a.name} (${a.currency}, ${a.status})`);
-      if (a.defaults.pageId) lines.push(`    Page: ${a.defaults.pageId}`);
-      if (a.defaults.pixelId) lines.push(`    Pixel: ${a.defaults.pixelId}`);
+  for (const [platformKey, label] of STATUS_PLATFORMS) {
+    const platform2 = platforms[platformKey];
+    if (!platform2.connected) {
+      lines.push(`${label}: not connected`);
+      continue;
+    }
+    lines.push(`${label}: connected`);
+    for (const account of platform2.accounts) {
+      const details = [account.currency, account.status].filter(Boolean).join(", ");
+      lines.push(`  ${account.id}${account.name ? ` \u2014 ${account.name}` : ""}${details ? ` (${details})` : ""}`);
+      const defaults = Object.entries(account.defaults ?? {});
+      for (const [key, value] of defaults) if (value) lines.push(`    ${DEFAULT_LABELS[key] ?? key}: ${value}`);
     }
-  } else lines.push("Meta: not connected");
-  if (platforms.google.connected) {
-    lines.push("Google: connected");
-    for (const a of platforms.google.accounts) lines.push(`  ${a.id} \u2014 ${a.name} (${a.currency})`);
-  } else lines.push("Google: not connected");
+  }
   lines.push("");
   lines.push(data.instructions);
-  console.log(lines.join("\n"));
+  const output = lines.join("\n");
+  console.log(output);
 }
 
 // src/commands/drafts.ts
@@ -3935,15 +4111,17 @@ function readStringFlag(flags, key) {
   const value = flags[key];
   return typeof value === "string" ? value : void 0;
 }
+var ADVERTISER_FILTER_FLAGS = ["industry", "category", "platform", "sort", "limit", "page"];
 async function listAdvertisers(client, _args, flags) {
-  const industry = typeof flags.industry === "string" ? flags.industry : void 0;
-  const category = typeof flags.category === "string" ? flags.category : void 0;
-  const platform2 = typeof flags.platform === "string" ? flags.platform : void 0;
-  const search = typeof flags.search === "string" ? flags.search : void 0;
-  const sort = typeof flags.sort === "string" ? flags.sort : "name";
-  const limit = typeof flags.limit === "string" ? flags.limit : void 0;
-  const page = typeof flags.page === "string" ? flags.page : void 0;
-  const qs = queryString3({ industry, category, platform: platform2, search, sort, limit, page });
+  validateFlags(flags, ADVERTISER_FILTER_FLAGS, "library advertisers list");
+  const qs = buildAdvertiserQueryString(flags);
+  return client.get(`/library/advertisers${qs}`);
+}
+async function searchAdvertisers(client, args, flags) {
+  validateFlags(flags, ADVERTISER_FILTER_FLAGS, "library advertisers search");
+  const query = args.join(" ").trim();
+  if (!query) throw new CliError("MISSING_ARGUMENT", "Missing advertiser search query", "Run: adkit library advertisers search <query>");
+  const qs = buildAdvertiserQueryString(flags, query);
   return client.get(`/library/advertisers${qs}`);
 }
 async function getAdvertiser(client, args, _flags) {
@@ -3975,6 +4153,15 @@ async function addAdvertiser(client, _args, flags) {
     linkedInLibraryUrl: linkedinLibrary
   });
 }
+function buildAdvertiserQueryString(flags, query) {
+  const industry = typeof flags.industry === "string" ? flags.industry : void 0;
+  const category = typeof flags.category === "string" ? flags.category : void 0;
+  const platform2 = typeof flags.platform === "string" ? flags.platform : void 0;
+  const sort = typeof flags.sort === "string" ? flags.sort : "name";
+  const limit = typeof flags.limit === "string" ? flags.limit : void 0;
+  const page = typeof flags.page === "string" ? flags.page : void 0;
+  return queryString3({ industry, category, platform: platform2, query, sort, limit, page });
+}
 async function listLibraryAds(client, _args, flags) {
   const platform2 = readStringFlag(flags, "platform");
   const status2 = readStringFlag(flags, "status");
@@ -4860,7 +5047,9 @@ Manage platforms:
   google        Google Ads
   tiktok        TikTok Ads
   reddit        Reddit Ads
+  x             X Ads
   linkedin      LinkedIn Ads
+  microsoft     Microsoft Ads
   drafts        Drafts across platforms
 
 Run \`adkit <command> --help\` for details.
@@ -6748,9 +6937,9 @@ Platforms:
   google              Google Ads
   tiktok              TikTok Ads
   reddit              Reddit Ads
-  x                   X Ads raw API access
+  x                   X account setup plus read-only campaigns, ad groups, ads, and results
   linkedin            LinkedIn Ads (campaigns, ad groups, ads, targeting, results)
-  microsoft           Microsoft Ads raw API access + account discovery
+  microsoft           Microsoft Ads raw API access + account setup
   drafts              Manage drafts across platforms
   platform-api-requests  Send raw API requests (escape hatch)
 
@@ -6836,18 +7025,122 @@ General flags:
 ${FLAG.account}
 
 Run adkit manage reddit accounts --help for account setup.`.trim(),
-  x: `adkit manage x \u2014 X Ads raw API access
+  x: `adkit manage x \u2014 X Ads management
 
-X is currently exposed through Advanced Platform Access only.
-Use platform-api-requests with official X Ads API endpoint paths.
+Entity groups:
+  accounts            Connect accounts and configure profile/pixel defaults
+  campaigns           List/get campaigns
+  ad-groups           List/get line items as ad groups
+  ads                 List/get promoted-Post associations
+  results             Campaign, ad-group, and ad performance
 
 ${rawPlatformCommandLine("x")}
 
 Examples:
-  adkit manage platform-api-requests --platform x --endpoint "accounts/18ce54d4x5t/campaigns" --method GET --request-description "List X campaigns" --account 18ce54d4x5t`.trim(),
-  microsoft: `adkit manage microsoft \u2014 Microsoft Ads raw API access + account discovery
+  adkit manage x accounts available
+  adkit manage x campaigns list --account 18ce54d4x5t
+  adkit manage x results --level ads --from 2026-08-01 --to 2026-08-07 --account 18ce54d4x5t`.trim(),
+  "x accounts": `adkit manage x accounts \u2014 X Ads accounts
+
+  list                List connected X ad accounts
+  available           List discoverable X ad accounts
+  connect <id>        Connect an X ad account
+  disconnect <id>     Disconnect an X ad account
+  <id> profiles       List X identities available to an account
+  <id> pixels         List X conversion pixels available to an account
+  <id> update         Save default identity and pixel IDs
 
-Microsoft (Bing) is currently exposed through Advanced Platform Access, plus account discovery.
+Flags:
+  --integration <id> Connect using a specific workspace login returned by available
+  --default-profile <id> Default X identity for ad creation
+  --default-pixel <id> Default X conversion pixel
+  --data <json>       Full update body; also supports null to clear a default
+
+Examples:
+  adkit manage x accounts list
+  adkit manage x accounts available
+  adkit manage x accounts connect 18ce54d4x5t
+  adkit manage x accounts 18ce54d4x5t profiles
+  adkit manage x accounts 18ce54d4x5t pixels
+  adkit manage x accounts 18ce54d4x5t update --default-profile 12abc --default-pixel p123
+  adkit manage x accounts disconnect 18ce54d4x5t`.trim(),
+  "x campaigns": `adkit manage x campaigns \u2014 X Ads campaigns (read-only)
+
+  list                List campaigns
+  get <id>            Get one campaign
+
+Flags:
+${FLAG.account}
+  --campaign-ids <ids> Comma-separated campaign platform IDs
+  --status <s>        active, paused, or removed
+  --limit <n>         Max rows
+  --offset <n>        Row offset
+
+Example:
+  adkit manage x campaigns list --status active
+  adkit manage x campaigns get 8v7jo`.trim(),
+  "x ad-groups": `adkit manage x ad-groups \u2014 X line items as AdKit ad groups (read-only)
+
+  list                List ad groups
+  get <id>            Get one ad group
+
+Flags:
+${FLAG.account}
+  --campaign-ids <ids> Comma-separated parent campaign IDs
+  --ad-group-ids <ids> Comma-separated line-item IDs
+  --status <s>        active, paused, or removed
+  --limit <n>         Max rows
+  --offset <n>        Row offset
+
+Example:
+  adkit manage x ad-groups list --campaign-ids 8v7jo`.trim(),
+  "x ads": `adkit manage x ads \u2014 X promoted-Post ads (read-only)
+
+  list                List promoted-Post ads
+  get <id>            Get one ad by promoted association ID
+
+Identity:
+  platformId is the promoted association ID used by X Ads and analytics. postId is the underlying Post ID.
+
+Flags:
+${FLAG.account}
+  --campaign-ids <ids> Comma-separated parent campaign IDs
+  --ad-group-ids <ids> Comma-separated parent line-item IDs
+  --ad-ids <ids>      Comma-separated promoted association IDs
+  --status <s>        active, paused, or removed
+  --limit <n>         Max rows
+  --offset <n>        Row offset
+
+Example:
+  adkit manage x ads get 1efwlo`.trim(),
+  "x results": `adkit manage x results \u2014 X Ads performance reporting (read-only)
+
+  list                List reporting rows (list is optional)
+
+Flags:
+${FLAG.account}
+  --level <level>     Required: campaigns, ad-groups, or ads
+  --from <date>       Required YYYY-MM-DD start
+  --to <date>         Required YYYY-MM-DD end
+  --fields <csv>      spend, impressions, clicks, ctr, cpc, cpm, outboundClicks, outboundCtr, costPerOutboundClick, videoViews
+  --breakdowns <csv>  day only
+  --campaign-ids <ids> Campaign filters
+  --ad-group-ids <ids> Ad-group filters
+  --ad-ids <ids>      Promoted association filters for level ads
+  --sort <field>      Metric to sort by (default: spend)
+  --sort-direction <d> asc or desc
+  --limit <n>         Max rows
+  --offset <n>        Row offset
+  --raw               Include queried placements in platformDetails
+
+Note:
+  X does not name one primary Results metric, so rows omit metrics.results and return conversionEvents: {}.
+
+Example:
+  adkit manage x results --level ads --from 2026-08-01 --to 2026-08-07 --fields spend,impressions,clicks`.trim(),
+  microsoft: `adkit manage microsoft \u2014 Microsoft Ads raw API access + account setup
+
+Microsoft (Bing) is currently exposed through Advanced Platform Access, plus account assignment.
 Endpoints are FULL https URLs to Bing Ads v13 hosts (campaign/reporting/bulk .api.bingads.microsoft.com) \u2014 not relative paths.
 Bing REST puts the operation in the HTTP verb; query reads are POST to .../Query* paths.
 Because query reads are POST, add --publish on read-only Query* calls \u2014 otherwise you get a draft instead of data.
@@ -6855,15 +7148,30 @@ Because query reads are POST, add --publish on read-only Query* calls \u2014 oth
 ${rawPlatformCommandLine("microsoft")}
 
 Commands:
-  accounts available   List Microsoft ad accounts discoverable from the connected workspace login
+  accounts             List, discover, connect, and disconnect Microsoft ad accounts
 
 Examples:
   adkit manage microsoft accounts available
   adkit manage platform-api-requests --platform microsoft --endpoint "https://campaign.api.bingads.microsoft.com/CampaignManagement/v13/Campaigns/QueryByAccountId" --payload '{"AccountId":187276743,"CampaignType":"Search"}' --request-description "List Microsoft campaigns" --account 187276743 --publish`.trim(),
+  "microsoft accounts": `adkit manage microsoft accounts \u2014 Microsoft Ads accounts
+
+  list                List connected Microsoft ad accounts
+  available           List discoverable Microsoft ad accounts
+  connect <id>        Connect a Microsoft ad account
+  disconnect <id>     Disconnect a Microsoft ad account
+
+Flags:
+  --integration <id> Connect using a specific workspace login returned by available
+
+Examples:
+  adkit manage microsoft accounts list
+  adkit manage microsoft accounts available
+  adkit manage microsoft accounts connect 187276743
+  adkit manage microsoft accounts disconnect 187276743`.trim(),
   linkedin: `adkit manage linkedin \u2014 LinkedIn Ads management
 
 Entity groups:
-  accounts            Discover LinkedIn ad accounts (available)
+  accounts            List, discover, connect, and disconnect LinkedIn ad accounts
   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)
@@ -6883,6 +7191,21 @@ ${FLAG.data}
 
 ${rawPlatformCommandLine("linkedin")}
 Run adkit manage linkedin <group> --help for details.`.trim(),
+  "linkedin accounts": `adkit manage linkedin accounts \u2014 LinkedIn Ads accounts
+
+  list                List connected LinkedIn ad accounts
+  available           List discoverable LinkedIn ad accounts
+  connect <id>        Connect a LinkedIn ad account
+  disconnect <id>     Disconnect a LinkedIn ad account
+
+Flags:
+  --integration <id> Connect using a specific workspace login returned by available
+
+Examples:
+  adkit manage linkedin accounts list
+  adkit manage linkedin accounts available
+  adkit manage linkedin accounts connect 512345678
+  adkit manage linkedin accounts disconnect 512345678`.trim(),
   drafts: `adkit manage drafts \u2014 Manage drafts
 
   list                List all drafts
@@ -8721,16 +9044,28 @@ async function main() {
         }
       } else if (platform2 === "linkedin") {
         switch (entity) {
-          case "accounts":
+          case "accounts": {
             switch (action) {
+              case "list":
+              case void 0:
+                data = await listLinkedInAccounts(client, restArgs, flags);
+                emptyHint = "No LinkedIn ad accounts connected. Connect a workspace login first if no accounts are available.";
+                break;
               case "available":
                 data = await listLinkedInAvailableAccounts(client, restArgs, flags);
                 emptyHint = "No LinkedIn ad accounts available from the connected workspace login.";
                 break;
+              case "connect":
+                data = await connectLinkedInAccount(client, restArgs, flags);
+                break;
+              case "disconnect":
+                data = await disconnectLinkedInAccount(client, restArgs, flags);
+                break;
               default:
-                throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin accounts ${action}`, "Available: available.");
+                throw new CliError("UNKNOWN_COMMAND", `Unknown action: linkedin accounts ${action}`, "Run: adkit manage linkedin accounts --help");
             }
             break;
+          }
           case "media": {
             if (!action) {
               showHelp("linkedin media", flags.help === "full");
@@ -8832,21 +9167,98 @@ async function main() {
         }
       } else if (platform2 === "microsoft") {
         switch (entity) {
-          case "accounts":
+          case "accounts": {
             switch (action) {
+              case "list":
+              case void 0:
+                data = await listMicrosoftAccounts(client, restArgs, flags);
+                emptyHint = "No Microsoft ad accounts connected. Connect a workspace login first if no accounts are available.";
+                break;
               case "available":
                 data = await listMicrosoftAvailableAccounts(client, restArgs, flags);
                 emptyHint = "No Microsoft ad accounts available from the connected workspace login.";
                 break;
+              case "connect":
+                data = await connectMicrosoftAccount(client, restArgs, flags);
+                break;
+              case "disconnect":
+                data = await disconnectMicrosoftAccount(client, restArgs, flags);
+                break;
               default:
-                throw new CliError("UNKNOWN_COMMAND", `Unknown action: microsoft accounts ${action}`, "Available: available.");
+                throw new CliError("UNKNOWN_COMMAND", `Unknown action: microsoft accounts ${action}`, "Run: adkit manage microsoft accounts --help");
             }
             break;
+          }
           default:
             throw new CliError("UNKNOWN_COMMAND", `Unknown entity: microsoft ${entity}`, "Available: accounts, 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, microsoft, drafts, platform-api-requests");
+      } else if (platform2 === "x") {
+        switch (entity) {
+          case "accounts": {
+            if (action && action !== "list" && action !== "available" && action !== "connect" && action !== "disconnect") {
+              const accountId = action;
+              const subcommand = args[4];
+              if (subcommand === "profiles") {
+                data = await listXProfiles(client, [accountId], flags);
+                emptyHint = "No X identities found for this account.";
+              } else if (subcommand === "pixels") {
+                data = await listXPixels(client, [accountId], flags);
+                emptyHint = "No X conversion pixels found for this account.";
+              } else if (subcommand === "update") data = await updateXAccount(client, [accountId], flags);
+              else throw new CliError("UNKNOWN_COMMAND", `Unknown subcommand: x accounts ${accountId} ${subcommand ?? ""}`, "Expected: profiles, pixels, or update");
+              break;
+            }
+            switch (action) {
+              case "list":
+              case void 0:
+                data = await listXAccounts(client, restArgs, flags);
+                emptyHint = "No X ad accounts connected. Connect a workspace login first if no accounts are available.";
+                break;
+              case "available":
+                data = await listXAvailableAccounts(client, restArgs, flags);
+                emptyHint = "No X ad accounts available from the connected workspace login.";
+                break;
+              case "connect":
+                data = await connectXAccount(client, restArgs, flags);
+                break;
+              case "disconnect":
+                data = await disconnectXAccount(client, restArgs, flags);
+                break;
+              default:
+                throw new CliError("UNKNOWN_COMMAND", `Unknown action: x accounts ${action}`, "Run: adkit manage x accounts --help");
+            }
+            break;
+          }
+          case "campaigns":
+            if (action === "list") {
+              data = await listXCampaigns(client, restArgs, flags);
+              emptyHint = "No X campaigns matched the selected filters.";
+            } else if (action === "get") data = await getXCampaign(client, restArgs, flags);
+            else throw new CliError("UNKNOWN_COMMAND", `Unknown action: x campaigns ${action}`, "Available: list, get");
+            break;
+          case "ad-groups":
+            if (action === "list") {
+              data = await listXAdGroups(client, restArgs, flags);
+              emptyHint = "No X ad groups matched the selected filters.";
+            } else if (action === "get") data = await getXAdGroup(client, restArgs, flags);
+            else throw new CliError("UNKNOWN_COMMAND", `Unknown action: x ad-groups ${action}`, "Available: list, get");
+            break;
+          case "ads":
+            if (action === "list") {
+              data = await listXAds(client, restArgs, flags);
+              emptyHint = "No X promoted-Post ads matched the selected filters.";
+            } else if (action === "get") data = await getXAd(client, restArgs, flags);
+            else throw new CliError("UNKNOWN_COMMAND", `Unknown action: x ads ${action}`, "Available: list, get");
+            break;
+          case "results":
+            if (action && action !== "list") throw new CliError("UNKNOWN_COMMAND", `Unknown action: x results ${action}`, "Available: list");
+            data = await listXResults(client, restArgs, flags);
+            emptyHint = "No X result rows matched the selected range and filters.";
+            break;
+          default:
+            throw new CliError("UNKNOWN_COMMAND", `Unknown entity: x ${entity}`, "Available: accounts, campaigns, ad-groups, ads, results, platform-api-requests");
+        }
+      } else throw new CliError("UNKNOWN_COMMAND", "Unknown platform", "Available: meta, google, tiktok, reddit, x, linkedin, microsoft, drafts, platform-api-requests");
       printResult(data, flags, emptyHint, detailEntity);
       return;
     }
@@ -8882,14 +9294,7 @@ async function main() {
             console.log(output || "No similar advertisers found. Try adjusting --industry, --category, or --tags filters.");
           }
         } else if (action === "search") {
-          const query = args.slice(3).join(" ");
-          if (!query) {
-            console.error("Usage: adkit library advertisers search <query>");
-            process.exitCode = 1;
-            return;
-          }
-          flags.search = query;
-          const data = await listAdvertisers(client, [], flags);
+          const data = await searchAdvertisers(client, args.slice(3), flags);
           if (wantsJson(flags)) printResult(data, flags, "No advertisers found matching your search.");
           else {
             const rows = unwrapList(data).map(formatLibraryAdvertiserRow);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adkit/cli",
-  "version": "1.13.26",
+  "version": "1.13.27",
   "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",