@curviate/cli 0.13.0 → 0.15.0

package/dist/job-TFTTCP5B.js

@@ -0,0 +1,561 @@
+#!/usr/bin/env node
+import {
+  BinaryOutputError,
+  writeBinaryOutput
+} from "./chunk-UWO2D4HW.js";
+import {
+  buildPreviewOutput
+} from "./chunk-R3VLWLVV.js";
+import {
+  slimJob
+} from "./chunk-45KHSWCV.js";
+import {
+  resolveJobIdentifier
+} from "./chunk-DMQZEPQE.js";
+import {
+  streamAll
+} from "./chunk-DNTRQZBT.js";
+import {
+  createClient,
+  renderError,
+  renderSuccess,
+  renderUnexpectedError,
+  resolveEffectiveConfig
+} from "./chunk-JXF47TRY.js";
+import {
+  GLOBAL_FLAGS,
+  READ_SINGLE_FLAGS,
+  WRITE_SINGLE_FLAGS
+} from "./chunk-4JHGVY7R.js";
+
+// src/commands/job.ts
+import { defineCommand } from "citty";
+var JOB_STATES = ["DRAFT", "OPEN", "CLOSED", "REVIEW", "SUSPENDED"];
+var WORKPLACE_TYPES = ["ON_SITE", "HYBRID", "REMOTE"];
+var EMPLOYMENT_STATUSES = ["FULL_TIME", "PART_TIME", "CONTRACT", "TEMPORARY", "OTHER", "VOLUNTEER", "INTERNSHIP"];
+var APPLY_METHODS = ["linkedin", "external"];
+var PUBLISH_MODES = ["FREE", "PROMOTED", "PROMOTED_PLUS"];
+var BUDGET_SCOPES = ["DAILY", "TOTAL"];
+var RATINGS = ["UNRATED", "NOT_A_FIT", "MAYBE", "GOOD_FIT"];
+function requestStateToItemState(state) {
+  return state === "OPEN" ? "LISTED" : state;
+}
+function filterJobsByState(items, requestedState) {
+  const source = items ?? [];
+  const wantedState = requestStateToItemState(requestedState);
+  const filtered = source.filter((item) => item.state === wantedState);
+  return { items: filtered, dropped: source.length - filtered.length };
+}
+function stateFilterDroppedNote(dropped, total, requestedState) {
+  return `note: LinkedIn's --state filter is best-effort -- dropped ${dropped} of ${total} returned item(s) on this page whose own state was not "${requestedState}". The page walk itself is unaffected (upstream pages are fetched unfiltered).
+`;
+}
+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
+  };
+}
+function requireFlag(value, flag, out) {
+  if (!value) {
+    out.stderr.write(`error: ${flag} is required.
+`);
+    process.exit(2);
+  }
+  return value;
+}
+function requireEnum(value, allowed, flag, out) {
+  if (!allowed.includes(value)) {
+    out.stderr.write(`error: ${flag} must be one of: ${allowed.join(", ")}. Got "${value}".
+`);
+    process.exit(2);
+  }
+}
+async function handleSdkError(err, outOpts, out) {
+  const { CurviateError } = await import("@curviate/sdk");
+  if (err instanceof CurviateError) {
+    const { getExitCode } = await import("./exit-codes-SL3GQF7W.js");
+    renderError(err, outOpts, out);
+    process.exit(getExitCode(err.code));
+  }
+  renderUnexpectedError(err, out);
+  process.exit(1);
+}
+function buildRef(idValue, nameValue) {
+  if (idValue) return { id: idValue };
+  if (nameValue) return { name: nameValue };
+  return void 0;
+}
+function buildApplyMethod(flags, out) {
+  const method = flags["apply-method"] ?? "";
+  requireEnum(method, APPLY_METHODS, "--apply-method", out);
+  if (method === "linkedin") {
+    const email = requireFlag(flags["notification-email"], "--notification-email (required when --apply-method is linkedin)", out);
+    return { method, notification_email: email };
+  }
+  const url = requireFlag(flags["website-url"], "--website-url (required when --apply-method is external)", out);
+  return { method, website_url: url };
+}
+async function runJobGet(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const resolvedId = resolveJobIdentifier(flags.id ?? "");
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.jobs.get(resolvedId);
+    renderSuccess(result, { ...outOpts, slim: slimJob }, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runJobList(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const state = requireFlag(flags.state, "--state", out);
+  requireEnum(state, JOB_STATES, "--state", 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 base = { state };
+  if (flags.limit) base.limit = parseInt(flags.limit, 10);
+  if (flags.cursor) base.cursor = flags.cursor;
+  try {
+    if (all) {
+      const fn = (p) => ns.jobs.list(p).then((page) => {
+        const { items: filtered, dropped } = filterJobsByState(page.items, state);
+        if (dropped > 0) {
+          out.stderr.write(stateFilterDroppedNote(dropped, page.items?.length ?? 0, state));
+        }
+        return { ...page, items: filtered };
+      });
+      for await (const item of streamAll(fn, base, {
+        maxPages,
+        out
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+    } else {
+      const result = await ns.jobs.list(base);
+      const { items: filtered, dropped } = filterJobsByState(result.items, state);
+      if (dropped > 0) {
+        out.stderr.write(stateFilterDroppedNote(dropped, result.items?.length ?? 0, state));
+      }
+      renderSuccess({ ...result, items: filtered }, outOpts, out);
+    }
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runJobBudget(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const jobId = resolveJobIdentifier(flags.id ?? "");
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.jobs.getBudget(jobId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runJobApplicants(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const jobId = resolveJobIdentifier(flags.id ?? "");
+  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 base = {};
+  if (flags.ratings) {
+    const ratings = flags.ratings.split(",").map((r) => r.trim()).filter(Boolean);
+    for (const r of ratings) requireEnum(r, RATINGS, "--ratings", out);
+    base.ratings = ratings;
+  }
+  if (flags.limit) base.limit = parseInt(flags.limit, 10);
+  if (flags.cursor) base.cursor = flags.cursor;
+  try {
+    if (all) {
+      const fn = (p) => ns.jobs.listApplicants(jobId, p);
+      for await (const item of streamAll(fn, base, {
+        maxPages,
+        out
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+    } else {
+      const result = await ns.jobs.listApplicants(jobId, base);
+      renderSuccess(result, outOpts, out);
+    }
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runJobApplicantGet(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const jobId = resolveJobIdentifier(flags.id ?? "");
+  const applicantId = flags.applicantId ?? "";
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.jobs.getApplicant(jobId, applicantId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runJobApplicantResume(client, flags, out, isTTY) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const jobId = resolveJobIdentifier(flags.id ?? "");
+  const applicantId = flags.applicantId ?? "";
+  const ns = client.account(accountId);
+  try {
+    const data = await ns.jobs.downloadResume(jobId, applicantId);
+    await writeBinaryOutput(data, { outputPath: flags.output, isTTY, stdout: process.stdout });
+  } catch (err) {
+    if (err instanceof BinaryOutputError) {
+      out.stderr.write(`error: ${err.message}
+`);
+      process.exit(err.exitCode);
+    }
+    await handleSdkError(err, resolveOutputOpts(flags), out);
+  }
+}
+async function runJobCreate(client, flags, out) {
+  const accountId = requireAccount(flags.account, out);
+  if (!flags["job-title"] && !flags["job-title-id"]) {
+    out.stderr.write("error: --job-title (a free-text name) or --job-title-id is required.\n");
+    process.exit(2);
+  }
+  if (!flags.company && !flags["company-id"]) {
+    out.stderr.write("error: --company (a free-text name) or --company-id is required.\n");
+    process.exit(2);
+  }
+  const workplaceType = requireFlag(flags["workplace-type"], "--workplace-type", out);
+  requireEnum(workplaceType, WORKPLACE_TYPES, "--workplace-type", out);
+  const location = requireFlag(flags.location, "--location", out);
+  const employmentStatus = requireFlag(flags["employment-status"], "--employment-status", out);
+  requireEnum(employmentStatus, EMPLOYMENT_STATUSES, "--employment-status", out);
+  const description = requireFlag(flags.description, "--description", out);
+  requireFlag(flags["apply-method"], "--apply-method", out);
+  const applyMethod = buildApplyMethod(flags, out);
+  const body = {
+    job_title: buildRef(flags["job-title-id"], flags["job-title"]),
+    company: buildRef(flags["company-id"], flags.company),
+    workplace_type: workplaceType,
+    location,
+    employment_status: employmentStatus,
+    description,
+    apply_method: applyMethod
+  };
+  if (flags.skills) {
+    body.skills = flags.skills.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (flags.preview) {
+    const preview = buildPreviewOutput({ method: "jobs.create", args: {}, body, account: accountId });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.jobs.create(body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runJobUpdate(client, flags, out) {
+  const accountId = requireAccount(flags.account, out);
+  const jobId = resolveJobIdentifier(flags.id ?? "");
+  const body = {};
+  const jobTitle = buildRef(flags["job-title-id"], flags["job-title"]);
+  if (jobTitle) body.job_title = jobTitle;
+  const company = buildRef(flags["company-id"], flags.company);
+  if (company) body.company = company;
+  if (flags["workplace-type"]) {
+    requireEnum(flags["workplace-type"], WORKPLACE_TYPES, "--workplace-type", out);
+    body.workplace_type = flags["workplace-type"];
+  }
+  if (flags.location) body.location = flags.location;
+  if (flags["employment-status"]) {
+    requireEnum(flags["employment-status"], EMPLOYMENT_STATUSES, "--employment-status", out);
+    body.employment_status = flags["employment-status"];
+  }
+  if (flags.description) body.description = flags.description;
+  if (flags["apply-method"]) body.apply_method = buildApplyMethod(flags, out);
+  if (flags.skills) body.skills = flags.skills.split(",").map((s) => s.trim()).filter(Boolean);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({ method: "jobs.update", args: { job_id: jobId }, body, account: accountId });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.jobs.update(jobId, body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runJobPublish(client, flags, out) {
+  const accountId = requireAccount(flags.account, out);
+  const jobId = resolveJobIdentifier(flags.id ?? "");
+  const mode = requireFlag(flags.mode, "--mode", out);
+  requireEnum(mode, PUBLISH_MODES, "--mode", out);
+  let body = { mode };
+  if (mode === "PROMOTED" || mode === "PROMOTED_PLUS") {
+    const currency = requireFlag(flags["budget-currency"], "--budget-currency (required for a paid publish)", out);
+    const amountRaw = requireFlag(flags["budget-amount"], "--budget-amount (required for a paid publish)", out);
+    const scope = requireFlag(flags["budget-scope"], "--budget-scope (required for a paid publish)", out);
+    requireEnum(scope, BUDGET_SCOPES, "--budget-scope", out);
+    const amount = Number(amountRaw);
+    if (!Number.isFinite(amount) || amount < 0) {
+      out.stderr.write("error: --budget-amount must be a non-negative number.\n");
+      process.exit(2);
+    }
+    body = { mode, budget: { currency, amount, scope } };
+  }
+  if (flags.preview) {
+    const preview = buildPreviewOutput({ method: "jobs.publish", args: { job_id: jobId }, body, account: accountId });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.jobs.publish(jobId, body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runJobClose(client, flags, out) {
+  const accountId = requireAccount(flags.account, out);
+  const jobId = resolveJobIdentifier(flags.id ?? "");
+  if (flags.preview) {
+    const preview = buildPreviewOutput({ method: "jobs.close", args: { job_id: jobId }, body: {}, account: accountId });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.jobs.close(jobId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function withClient(flags, fn) {
+  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 fn(client, { ...flags, account: flags.account ?? cfg.account }, out);
+}
+var JOB_BODY_FLAGS = {
+  "job-title": { type: "string", description: "Job title as free text (or use --job-title-id for an existing LinkedIn title)." },
+  "job-title-id": { type: "string", description: "Existing LinkedIn job-title id." },
+  company: { type: "string", description: "Hiring company as free text (or use --company-id)." },
+  "company-id": { type: "string", description: "Existing company id." },
+  "workplace-type": { type: "string", description: "Workplace arrangement: ON_SITE|HYBRID|REMOTE." },
+  location: { type: "string", description: "A LOCATION parameter id (from search parameters)." },
+  "employment-status": { type: "string", description: "Employment type: FULL_TIME|PART_TIME|CONTRACT|TEMPORARY|OTHER|VOLUNTEER|INTERNSHIP." },
+  description: { type: "string", description: "Full job description (min 200 chars)." },
+  "apply-method": { type: "string", description: "How candidates apply: linkedin|external." },
+  "notification-email": { type: "string", description: "Email notified of new applicants (required when --apply-method is linkedin)." },
+  "website-url": { type: "string", description: "External apply URL (required when --apply-method is external)." },
+  skills: { type: "string", description: "Comma-separated skill parameter ids (optional)." }
+};
+var jobGetCommand = defineCommand({
+  meta: { name: "get", description: "Retrieve one public LinkedIn job posting's full detail." },
+  args: {
+    ...READ_SINGLE_FLAGS,
+    id: { type: "positional", description: "Job URL or a bare numeric job id." }
+  },
+  async run({ args }) {
+    await withClient(args, runJobGet);
+  }
+});
+var jobListCommand = defineCommand({
+  meta: { name: "list", description: "List your own classic job postings by state." },
+  args: {
+    ...GLOBAL_FLAGS,
+    state: { type: "string", description: "Filter by state (required): DRAFT|OPEN|CLOSED|REVIEW|SUSPENDED. Best-effort on LinkedIn's side -- verify item.state. The CLI re-filters returned items against their own state (dropped items are noted on stderr), but the upstream page walk itself is unfiltered, so --all may fetch more pages than the filtered item count implies.", required: true }
+  },
+  async run({ args }) {
+    await withClient(args, runJobList);
+  }
+});
+var jobCreateCommand = defineCommand({
+  meta: { name: "create", description: "Create a classic job-posting draft (never publishes, never spends)." },
+  args: {
+    ...WRITE_SINGLE_FLAGS,
+    ...JOB_BODY_FLAGS
+  },
+  async run({ args }) {
+    await withClient(args, runJobCreate);
+  }
+});
+var jobUpdateCommand = defineCommand({
+  meta: { name: "update", description: "Apply a partial update to a job posting you own." },
+  args: {
+    ...WRITE_SINGLE_FLAGS,
+    id: { type: "positional", description: "Job id to update." },
+    ...JOB_BODY_FLAGS
+  },
+  async run({ args }) {
+    await withClient(args, runJobUpdate);
+  }
+});
+var jobBudgetCommand = defineCommand({
+  meta: { name: "budget", description: "Price a publish before committing any money." },
+  args: {
+    ...READ_SINGLE_FLAGS,
+    id: { type: "positional", description: "Job id to price." }
+  },
+  async run({ args }) {
+    await withClient(args, runJobBudget);
+  }
+});
+var jobPublishCommand = defineCommand({
+  meta: { name: "publish", description: "Publish a draft. PROMOTED/PROMOTED_PLUS spend real money and require --budget-*." },
+  args: {
+    ...WRITE_SINGLE_FLAGS,
+    id: { type: "positional", description: "Job id to publish." },
+    mode: { type: "string", description: "Publish mode (required): FREE|PROMOTED|PROMOTED_PLUS.", required: true },
+    "budget-currency": { type: "string", description: "ISO-4217 currency (required for a paid publish), e.g. EUR." },
+    "budget-amount": { type: "string", description: "Budget amount (required for a paid publish)." },
+    "budget-scope": { type: "string", description: "Budget scope (required for a paid publish): DAILY|TOTAL." }
+  },
+  async run({ args }) {
+    await withClient(args, runJobPublish);
+  }
+});
+var jobCloseCommand = defineCommand({
+  meta: { name: "close", description: "Stop a posting from accepting applications (irreversible once LISTED)." },
+  args: {
+    ...WRITE_SINGLE_FLAGS,
+    id: { type: "positional", description: "Job id to close." }
+  },
+  async run({ args }) {
+    await withClient(args, runJobClose);
+  }
+});
+var jobApplicantsCommand = defineCommand({
+  meta: { name: "applicants", description: "List applicants to a posting you own (POST-as-search)." },
+  args: {
+    ...GLOBAL_FLAGS,
+    id: { type: "positional", description: "Job id to list applicants for." },
+    ratings: { type: "string", description: "Comma-separated rating filter: UNRATED|NOT_A_FIT|MAYBE|GOOD_FIT. Omit for the full funnel." }
+  },
+  async run({ args }) {
+    await withClient(args, runJobApplicants);
+  }
+});
+var jobApplicantGetCommand = defineCommand({
+  meta: { name: "get", description: "Get one applicant's full detail, including contact info." },
+  args: {
+    ...READ_SINGLE_FLAGS,
+    id: { type: "positional", description: "Job id the applicant applied to." },
+    applicantId: { type: "positional", description: "Applicant id." }
+  },
+  async run({ args }) {
+    await withClient(args, runJobApplicantGet);
+  }
+});
+var jobApplicantResumeCommand = defineCommand({
+  meta: { name: "resume", description: "Download an applicant's r\xE9sum\xE9 (binary)." },
+  args: {
+    ...READ_SINGLE_FLAGS,
+    id: { type: "positional", description: "Job id the applicant applied to." },
+    applicantId: { type: "positional", description: "Applicant id." },
+    output: { type: "string", alias: "o", description: "Path to write the r\xE9sum\xE9 file to." }
+  },
+  async run({ args }) {
+    await withClient(args, (c, f, o) => runJobApplicantResume(c, f, o, process.stdout.isTTY ?? false));
+  }
+});
+var jobApplicantCommand = defineCommand({
+  meta: { name: "applicant", description: "Applicant detail + r\xE9sum\xE9 for a posting you own." },
+  args: { ...READ_SINGLE_FLAGS },
+  subCommands: {
+    get: jobApplicantGetCommand,
+    resume: jobApplicantResumeCommand
+  },
+  async run() {
+    process.stderr.write(
+      "Usage: curviate job applicant get <job_id> <applicant_id>\n       curviate job applicant resume <job_id> <applicant_id> -o <file>\n"
+    );
+  }
+});
+var jobCommand = defineCommand({
+  meta: { name: "job", description: "Classic LinkedIn job-posting operations." },
+  args: { ...READ_SINGLE_FLAGS },
+  subCommands: {
+    get: jobGetCommand,
+    list: jobListCommand,
+    create: jobCreateCommand,
+    update: jobUpdateCommand,
+    budget: jobBudgetCommand,
+    publish: jobPublishCommand,
+    close: jobCloseCommand,
+    applicants: jobApplicantsCommand,
+    applicant: jobApplicantCommand
+  },
+  async run() {
+    process.stderr.write(
+      "Usage: curviate job get <url|id>\n       curviate job list --state <DRAFT|OPEN|CLOSED|REVIEW|SUSPENDED>\n       curviate job create --job-title <t> --company <c> --workplace-type <w> --location <id> --employment-status <e> --description <d> --apply-method <linkedin|external>\n       curviate job update <id> [<flags>]\n       curviate job budget <id>\n       curviate job publish <id> --mode <FREE|PROMOTED|PROMOTED_PLUS>\n       curviate job close <id>\n       curviate job applicants <id>\n       curviate job applicant get <id> <applicant_id>\n       curviate job applicant resume <id> <applicant_id> -o <file>\n"
+    );
+  }
+});
+export {
+  jobCommand,
+  runJobApplicantGet,
+  runJobApplicantResume,
+  runJobApplicants,
+  runJobBudget,
+  runJobClose,
+  runJobCreate,
+  runJobGet,
+  runJobList,
+  runJobPublish,
+  runJobUpdate
+};