@curviate/cli 0.18.1 → 0.19.0

package/CHANGELOG.md

@@ -8,6 +8,34 @@ a new command or flag is a minor; a breaking command/flag/exit-code change is a
 
 ## [Unreleased]
 
+## [0.19.0] - 2026-07-29
+
+A minor release closing the remaining SDK-parity gap: 25 new commands across seven
+existing command groups plus three brand-new command groups. No breaking changes,
+built against `@curviate/sdk` 0.18.1 (unchanged; every new command was already
+covered by the published SDK, so no SDK bump was required).
+
+### Added
+
+- **`inbox search`** — search chats via `messaging.searchChats`.
+- **`search groups`, `search services`, `search service-parameters`** — new search
+  surfaces for groups, services, and service search parameters.
+- **`post saved`, `post save`, `post unsave`** — list, save, and unsave posts.
+- **`company managed`, `company followers`, `company chats`, `company chat`,
+  `company messages`, `company message`, `company search-chats`** — company-inbox
+  and managed-company read/write surface.
+- **`profile subscription`, `profile analytics`, `profile visitors`, `profile ssi`**
+  — account-scoped profile insight subcommands (subscription status, post/profile
+  analytics, visitor list, Social Selling Index).
+- **`group` command group** — new top-level group closing the LinkedIn Groups gap.
+- **`feed`, `feed home`** — new command group to read the connected account's
+  LinkedIn home feed as agent-actionable posts.
+- **`notification`, `notification list`, `notification delete`,
+  `notification show-less`** — new command group to read and act on LinkedIn
+  notification cards.
+
+Parity with the SDK surface is now 145/0 (no known gaps).
+
 ## [0.18.1] - 2026-07-18
 
 A patch aligning `company reply` with the company-inbox chat-id cutover. No breaking changes, built against `@curviate/sdk` 0.18.1.

package/dist/cli.js

@@ -42,9 +42,6 @@ var REMOVED_COMMANDS = {
   },
   webhook: {
     "state-diff": "`webhook state-diff` was removed with no replacement."
-  },
-  company: {
-    followers: "`company followers` was removed with no replacement."
   }
 };
 function successorHint(group, token) {
@@ -255,20 +252,23 @@ var main = defineCommand({
     // ---------------------------------------------------------------------------
     // Noun groups — lazy-loaded on first invocation.
     // ---------------------------------------------------------------------------
-    profile: () => import("./profile-XWSRUYRW.js").then((m) => m.profileCommand),
-    company: () => import("./company-BVXX4FGX.js").then((m) => m.companyCommand),
+    profile: () => import("./profile-PES67647.js").then((m) => m.profileCommand),
+    company: () => import("./company-XEEBBCRZ.js").then((m) => m.companyCommand),
     job: () => import("./job-EIXBJXLW.js").then((m) => m.jobCommand),
     connect: () => import("./connect-6PU7QCOL.js").then((m) => m.connectCommand),
-    search: () => import("./search-ZQUKLQ6T.js").then((m) => m.searchCommand),
-    inbox: () => import("./inbox-DRJ6ENXC.js").then((m) => m.inboxCommand),
+    search: () => import("./search-O2LACGHE.js").then((m) => m.searchCommand),
+    inbox: () => import("./inbox-BXCWHGWP.js").then((m) => m.inboxCommand),
     inboxes: () => import("./inboxes-MTPWLP5F.js").then((m) => m.inboxesCommand),
     message: () => import("./message-UWMRE2SJ.js").then((m) => m.messageCommand),
-    post: () => import("./post-N3GQDIQJ.js").then((m) => m.postCommand),
+    post: () => import("./post-HK6HHIKV.js").then((m) => m.postCommand),
     comment: () => import("./comment-VT6PO4MN.js").then((m) => m.commentCommand),
     account: () => import("./account-EGJJNBXW.js").then((m) => m.accountCommand),
     webhook: () => import("./webhook-QFSZN3P2.js").then((m) => m.webhookCommand),
     "sales-nav": () => import("./sales-nav-TMXWDKSE.js").then((m) => m.salesNavCommand),
-    recruiter: () => import("./recruiter-MVPSTH2V.js").then((m) => m.recruiterCommand)
+    recruiter: () => import("./recruiter-MVPSTH2V.js").then((m) => m.recruiterCommand),
+    group: () => import("./group-LPVVJ2JX.js").then((m) => m.groupCommand),
+    feed: () => import("./feed-KAUDRE5K.js").then((m) => m.feedCommand),
+    notification: () => import("./notification-RYFDHM3G.js").then((m) => m.notificationCommand)
   },
   async run() {
     const { runMain } = await import("citty");

package/dist/{company-BVXX4FGX.js → company-XEEBBCRZ.js}

@@ -261,6 +261,186 @@ async function runCompanyFollowInvite(client, flags, out) {
     await handleSdkError(err, outOpts, out);
   }
 }
+async function runCompanyManaged(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const params = {};
+  if (flags.limit) params["limit"] = parseInt(flags.limit, 10);
+  if (flags.cursor) params["cursor"] = flags.cursor;
+  try {
+    if (flags.all) {
+      const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+      const fn = (p) => ns.companies.managed(p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+      return;
+    }
+    const result = await ns.companies.managed(params);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runCompanyFollowers(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const params = {};
+  if (flags.limit) params["limit"] = parseInt(flags.limit, 10);
+  if (flags.cursor) params["cursor"] = flags.cursor;
+  try {
+    const identifier = await resolveCompanyId(ns, flags.id ?? "");
+    if (flags.all) {
+      const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+      const fn = (p) => ns.companies.followers(identifier, p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+      return;
+    }
+    const result = await ns.companies.followers(identifier, params);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runCompanyChats(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const params = {};
+  if (flags.limit) params["limit"] = parseInt(flags.limit, 10);
+  if (flags.cursor) params["cursor"] = flags.cursor;
+  try {
+    const identifier = await resolveCompanyId(ns, flags.id ?? "");
+    if (flags.all) {
+      const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+      const fn = (p) => ns.companies.chats(identifier, p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+      return;
+    }
+    const result = await ns.companies.chats(identifier, params);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runCompanyChat(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  if (flags.all) {
+    out.stderr.write("error: --all is not supported on non-paginated commands.\n");
+    process.exit(2);
+  }
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const chatId = flags.chatId ?? "";
+  try {
+    const identifier = await resolveCompanyId(ns, flags.id ?? "");
+    const result = await ns.companies.chat(identifier, chatId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runCompanyMessages(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const chatId = flags.chatId ?? "";
+  const params = {};
+  if (flags.limit) params["limit"] = parseInt(flags.limit, 10);
+  if (flags.cursor) params["cursor"] = flags.cursor;
+  try {
+    const identifier = await resolveCompanyId(ns, flags.id ?? "");
+    if (flags.all) {
+      const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+      const fn = (p) => ns.companies.messages(identifier, chatId, p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+      return;
+    }
+    const result = await ns.companies.messages(identifier, chatId, params);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runCompanyMessage(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  if (flags.all) {
+    out.stderr.write("error: --all is not supported on non-paginated commands.\n");
+    process.exit(2);
+  }
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const chatId = flags.chatId ?? "";
+  const messageId = flags.messageId ?? "";
+  try {
+    const identifier = await resolveCompanyId(ns, flags.id ?? "");
+    const result = await ns.companies.message(identifier, chatId, messageId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runCompanySearchChats(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const params = {};
+  if (flags.query) params["query"] = flags.query;
+  if (flags.topic) params["topic"] = flags.topic;
+  if (flags.unread !== void 0) params["unread"] = flags.unread;
+  if (flags.limit) params["limit"] = parseInt(flags.limit, 10);
+  if (flags.cursor) params["cursor"] = flags.cursor;
+  try {
+    const identifier = await resolveCompanyId(ns, flags.id ?? "");
+    if (flags.all) {
+      const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+      const fn = (p) => ns.companies.searchChats(identifier, p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+      return;
+    }
+    const result = await ns.companies.searchChats(identifier, params);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
 async function runCompanyReply(client, flags, out, _readStdin) {
   const accountId = requireAccount(flags.account, out);
   const ns = client.account(accountId);
@@ -315,7 +495,7 @@ var companyEmployeesCommand = defineCommand({
   meta: { name: "employees", description: "List people who currently work at the company." },
   args: {
     ...GLOBAL_FLAGS,
-    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id) \u2014 a slug/URL is resolved to the numeric id first." },
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." },
     keywords: { type: "string", description: "Free-text keyword filter across employee profile fields." },
     location: { type: "string", description: "Opaque location id from `search parameters --type LOCATION`." }
   },
@@ -341,7 +521,7 @@ var companyPostsCommand = defineCommand({
   meta: { name: "posts", description: "List the company's posts." },
   args: {
     ...GLOBAL_FLAGS,
-    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id) \u2014 a slug/URL is resolved to the numeric id first." }
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." }
   },
   async run({ args }) {
     const flags = args;
@@ -365,7 +545,7 @@ var companyJobsCommand = defineCommand({
   meta: { name: "jobs", description: "List the company's open job postings." },
   args: {
     ...GLOBAL_FLAGS,
-    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id) \u2014 a slug/URL is resolved to the numeric id first." },
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." },
     keywords: { type: "string", description: "Free-text keyword filter across job postings." }
   },
   async run({ args }) {
@@ -444,6 +624,193 @@ var companyFollowInviteCommand = defineCommand({
     await runCompanyFollowInvite(client, { ...flags, account: flags.account ?? cfg.account }, out);
   }
 });
+var companyManagedCommand = defineCommand({
+  meta: { name: "managed", description: "List the company pages the connected account administers. An empty result is valid, the account administers no pages." },
+  args: { ...GLOBAL_FLAGS },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runCompanyManaged(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var companyFollowersCommand = defineCommand({
+  meta: { name: "followers", description: "List a company page's followers, newest first. Admin-gated: the account must administer the page (see `company managed`)." },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runCompanyFollowers(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var companyChatsCommand = defineCommand({
+  meta: {
+    name: "chats",
+    description: "List the conversations in a company page's admin message inbox, newest-activity-first. Admin-gated. Beta."
+  },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runCompanyChats(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var companyChatCommand = defineCommand({
+  meta: {
+    name: "chat",
+    description: "Retrieve one conversation from a company page's admin inbox. Admin-gated. Beta."
+  },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." },
+    chatId: { type: "positional", description: "The 2-\u2026 chat id from `company chats`, passed through verbatim." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runCompanyChat(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var companyMessagesCommand = defineCommand({
+  meta: {
+    name: "messages",
+    description: "List a company-inbox conversation's messages, newest first. Admin-gated."
+  },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." },
+    chatId: { type: "positional", description: "The 2-\u2026 chat id from `company chats`, passed through verbatim." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runCompanyMessages(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var companyMessageCommand = defineCommand({
+  meta: {
+    name: "message",
+    description: "Retrieve one message from a company-inbox conversation. Admin-gated. See also: `company reply` (send)."
+  },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." },
+    chatId: { type: "positional", description: "The 2-\u2026 chat id from `company chats`, passed through verbatim." },
+    messageId: { type: "positional", description: "The message id from `company messages`, passed through verbatim." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runCompanyMessage(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var companySearchChatsCommand = defineCommand({
+  meta: {
+    name: "search-chats",
+    description: "Search or filter a company page's admin inbox. Exactly one mode per call: free-text <query>, --topic, or --unread; mutually exclusive, enforced server-side. Admin-gated."
+  },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Company identifier (URL, slug, or numeric id), a slug/URL is resolved to the numeric id first." },
+    query: { type: "positional", required: false, description: "Free-text term, matches participant names and message content." },
+    topic: { type: "string", description: "Filter mode, one inbox topic card: 1-5 or its name (Service request, Request a demo, Support, Careers, Other)." },
+    unread: { type: "boolean", description: "Filter mode, unread conversations only." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runCompanySearchChats(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
 var companyReplyCommand = defineCommand({
   meta: {
     name: "reply",
@@ -490,7 +857,14 @@ var companyCommand = defineCommand({
     jobs: companyJobsCommand,
     "invitable-followers": companyInvitableFollowersCommand,
     "follow-invite": companyFollowInviteCommand,
-    reply: companyReplyCommand
+    reply: companyReplyCommand,
+    managed: companyManagedCommand,
+    followers: companyFollowersCommand,
+    chats: companyChatsCommand,
+    chat: companyChatCommand,
+    messages: companyMessagesCommand,
+    message: companyMessageCommand,
+    "search-chats": companySearchChatsCommand
   },
   async run({ args }) {
     const flags = args;
@@ -512,11 +886,18 @@ var companyCommand = defineCommand({
 });
 export {
   companyCommand,
+  runCompanyChat,
+  runCompanyChats,
   runCompanyEmployees,
   runCompanyFollowInvite,
+  runCompanyFollowers,
   runCompanyGet,
   runCompanyInvitableFollowers,
   runCompanyJobs,
+  runCompanyManaged,
+  runCompanyMessage,
+  runCompanyMessages,
   runCompanyPosts,
-  runCompanyReply
+  runCompanyReply,
+  runCompanySearchChats
 };

package/dist/feed-KAUDRE5K.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import {
+  pageDelayFromFlags,
+  streamAll
+} from "./chunk-EEMJDJ4W.js";
+import {
+  createClient,
+  renderError,
+  renderSuccess,
+  renderUnexpectedError,
+  resolveEffectiveConfig
+} from "./chunk-M33MI53G.js";
+import {
+  GLOBAL_FLAGS
+} from "./chunk-TMU3CSPR.js";
+
+// src/commands/feed.ts
+import { defineCommand } from "citty";
+function buildOutputStreams() {
+  return {
+    stdout: { write: (s) => process.stdout.write(s) },
+    stderr: { write: (s) => process.stderr.write(s) }
+  };
+}
+function requireAccount(account, out) {
+  if (!account) {
+    out.stderr.write("error: --account is required for this command. Set it via --account, CURVIATE_ACCOUNT, or `curviate config set-account`.\n");
+    process.exit(2);
+  }
+  return account;
+}
+function rejectPreviewOnRead(preview, out) {
+  if (preview) {
+    out.stderr.write("error: --preview is only valid on write commands (mutations). Reads just run.\n");
+    process.exit(2);
+  }
+}
+function resolveOutputOpts(flags) {
+  return {
+    json: (flags.json ?? false) || !process.stdout.isTTY,
+    isTTY: process.stdout.isTTY ?? false,
+    fields: flags.fields,
+    verbose: flags.verbose ?? false
+  };
+}
+async function handleSdkError(err, outOpts, out) {
+  const { CurviateError } = await import("@curviate/sdk");
+  if (err instanceof CurviateError) {
+    const { getExitCode } = await import("./exit-codes-63JE5GM5.js");
+    renderError(err, outOpts, out);
+    process.exit(getExitCode(err.code));
+  }
+  renderUnexpectedError(err, out);
+  process.exit(1);
+}
+async function runFeedHome(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const all = flags.all ?? false;
+  const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+  const params = {};
+  if (flags.sort) params["sort"] = flags.sort;
+  if (flags.limit) params["limit"] = parseInt(flags.limit, 10);
+  if (flags.cursor) params["cursor"] = flags.cursor;
+  try {
+    if (all) {
+      const fn = (p) => ns.feed.home(p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        out,
+        pageDelayMs: pageDelayFromFlags(flags)
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+    } else {
+      const result = await ns.feed.home(params);
+      renderSuccess(result, outOpts, out);
+    }
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+var FEED_ARGS = {
+  ...GLOBAL_FLAGS,
+  sort: {
+    type: "string",
+    description: "Sort order: recent (default, reverse-chronological, always available) or relevant (LinkedIn's ranked 'top' feed, shared throttled budget). Ignored when --cursor is supplied."
+  }
+};
+var feedHomeCommand = defineCommand({
+  meta: { name: "home", description: "Read the connected account's LinkedIn home feed as agent-actionable posts." },
+  args: FEED_ARGS,
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runFeedHome(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var feedCommand = defineCommand({
+  meta: { name: "feed", description: "Read the connected account's LinkedIn home feed as agent-actionable posts." },
+  subCommands: {
+    home: feedHomeCommand
+  },
+  async run() {
+    process.stderr.write(
+      "Usage: curviate feed <subcommand>\n  home [--sort recent|relevant] [--limit] [--cursor] [--all]\n"
+    );
+  }
+});
+export {
+  feedCommand,
+  runFeedHome
+};