@wport/cli 0.4.0 → 0.6.0

package/dist/index.js

@@ -179,7 +179,7 @@ function isTimeoutAbort(err) {
   return false;
 }
 function buildUserAgent() {
-  return `wport-cli/${"0.4.0"} (node ${process.version}; ${process.platform})`;
+  return `wport-cli/${"0.6.0"} (node ${process.version}; ${process.platform})`;
 }
 function unwrapDataResponse(body) {
   if (body && typeof body === "object" && "success" in body && "data" in body) {
@@ -663,6 +663,25 @@ function readJsonInput(source, options = {}) {
     throw new InvalidArgumentError("Invalid JSON in input (parse failed)");
   }
 }
+function readTextInput(source, options = {}) {
+  const readStdin = options.readStdin ?? ((label) => readPipedStdin(label, { timeoutMs: options.timeoutMs }));
+  let raw;
+  if (source === "-") {
+    raw = readStdin("--body-file -");
+  } else {
+    try {
+      raw = (0, import_node_fs3.readFileSync)(source, "utf8");
+    } catch (err) {
+      throw new InvalidArgumentError(
+        `Cannot read --body-file "${source}": ${err.code ?? err.message}`
+      );
+    }
+  }
+  if (!raw.trim()) {
+    throw new InvalidArgumentError("Input is empty \u2014 expected message body text");
+  }
+  return raw;
+}
 function readJsonObject(source, options = {}) {
   const parsed = readJsonInput(source, options);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -953,13 +972,20 @@ function registerConfigCommand(program2) {
 // src/commands/doctor.ts
 var import_node_fs5 = require("fs");
 var SILENT_IGNORED_PARAMS = ["orderBy", "order"];
+var ENTERPRISE_TALENT_BOUNDARY_NOTES = [
+  "`enterprise talents` covers your APPLIED pool only (list / view / respond).",
+  "The visit tab is not available yet: `talents list --tab visit` returns 400.",
+  "There is NO active candidate search over an API Key. `/api/search-talent` needs an",
+  "interactive JWT (company-mode) session and returns 401 for an API Key \u2014 by design,",
+  "not a setup error. Do not script talent-sourcing against an Enterprise API Key."
+];
 function registerDoctorCommand(program2) {
   program2.command("doctor").description(
     "Diagnose CLI setup: resolved config, server reachability, schema fingerprint, and known server quirks."
   ).action(async (_opts, command) => {
     const ctx = resolveContext(command);
     const line = (s = "") => process.stdout.write(s + "\n");
-    line(`wport-cli ${"0.4.0"}`);
+    line(`wport-cli ${"0.6.0"}`);
     line(`  bundled schema fingerprint: ${"839e8a891dfb"}`);
     line("");
     line("Resolved configuration:");
@@ -979,6 +1005,9 @@ function registerDoctorCommand(program2) {
     line("  \u2022 jobs search sorts by publish date, or by relevance when --keyword is set.");
     line("  \u2022 jobs view --batch caps parallelism (default 5, max 20) to stay friendly to the API.");
     line("");
+    line("Enterprise talent scope (Enterprise API Key):");
+    for (const note of ENTERPRISE_TALENT_BOUNDARY_NOTES) line(`  \u2022 ${note}`);
+    line("");
     line("Schema drift:");
     line("  The fingerprint above identifies the OpenAPI contract this CLI was built against.");
     line("  Automated drift detection needs a server-side schema-version endpoint, which is");
@@ -1068,8 +1097,25 @@ function throwEnterpriseHttpError(status, body) {
       ExitCode.ServerClientError
     );
   }
+  if (status === 400) {
+    const missingFields = extractMissingFields(body);
+    if (missingFields.length > 0) {
+      throw new CliError(
+        `${base} \u2014 Missing required fields: ${missingFields.join(", ")}. Fill them via \`wport enterprise jobs update <enc_id> ...\` (or the web console), then publish.`,
+        ExitCode.ServerClientError
+      );
+    }
+  }
   throwForHttpStatus(status, body);
 }
+function extractMissingFields(body) {
+  if (!body || typeof body !== "object") return [];
+  const data = body.data;
+  if (!data || typeof data !== "object") return [];
+  const fields = data.missing_fields;
+  if (!Array.isArray(fields)) return [];
+  return fields.filter((f) => typeof f === "string");
+}
 function warnIfRateLimitLow(headers) {
   const remaining = Number(headers.get("x-ratelimit-remaining"));
   const limit = Number(headers.get("x-ratelimit-limit"));
@@ -1251,6 +1297,41 @@ function registerEnterpriseWhoami(parent) {
   });
 }
 
+// src/commands/enterprise/usage.ts
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : "\u2014";
+}
+async function runUsage(ctx, apiKey) {
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/usage"
+  );
+  const usage = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(usage);
+    return;
+  }
+  const quota = usage.quota ?? {};
+  const rate = usage.rate_limit ?? {};
+  const lines = [
+    `period:         ${usage.period ?? "\u2014"}`,
+    `monthly quota:  ${num(quota.used)} / ${num(quota.limit)} used  (${num(quota.remaining)} remaining)`,
+    `rate limit:     ${num(rate.limit)} requests / ${num(rate.window_seconds)}s per key`
+  ];
+  process.stdout.write(lines.join("\n") + "\n");
+  process.stdout.write(
+    dim("Live per-window rate-limit headroom is reported via response headers on write requests.", ctx.color) + "\n"
+  );
+}
+function registerEnterpriseUsage(parent) {
+  parent.command("usage").description("Show this month API quota usage and rate-limit ceiling").action(async (_flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runUsage(ctx, key);
+  });
+}
+
 // src/commands/enterprise/jobs/list.ts
 var STATUS_MAP = { published: 1, unpublished: 0 };
 var MINIMAL_LIST_FIELDS = ["enc_id", "job_title", "status", "updated_at"];
@@ -1270,44 +1351,51 @@ function formatStatus(status) {
 function formatDate2(value) {
   return value ? String(value).slice(0, 10) : "";
 }
+function formatCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : "\u2014";
+}
+async function runEnterpriseJobsList(ctx, apiKey, flags) {
+  if (flags.fields && flags.minimal) {
+    throw new CliError("Use either --fields or --minimal, not both", ExitCode.InvalidArgument);
+  }
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/jobs",
+    {
+      currentPage: flags.page,
+      pageSize: flags.pageSize,
+      keyword: flags.keyword,
+      status: mapStatusFlag(flags.status)
+    }
+  );
+  const paged = asPaginatedBody(body);
+  const projection = flags.minimal ? MINIMAL_LIST_FIELDS : flags.fields ? parseFieldsList(flags.fields) : void 0;
+  if (projection || ctx.format === "json") {
+    printJson(projection ? { ...paged, data: paged.data.map((row) => pickPaths(row, projection)) } : paged);
+    return;
+  }
+  printTable(
+    paged.data,
+    [
+      { header: "ENC_ID", value: (r) => (r.enc_id ?? "").slice(0, 14) },
+      { header: "TITLE", value: (r) => r.job_title ?? "", maxWidth: 36 },
+      { header: "STATUS", value: (r) => formatStatus(r.status) },
+      { header: "CLICKS_7D", value: (r) => formatCount(r.clicks_7d) },
+      { header: "PUBLISHED", value: (r) => formatDate2(r.published_at), maxWidth: 12 },
+      { header: "UPDATED", value: (r) => formatDate2(r.updated_at), maxWidth: 12 }
+    ],
+    ctx.color
+  );
+  const head = `Showing page ${paged.currentPage}/${paged.totalPages} (${paged.data.length} of ${paged.totalCount} jobs).`;
+  const hint = paged.totalPages > paged.currentPage ? `  Next: wport enterprise jobs list --page ${paged.currentPage + 1}` : "";
+  process.stdout.write(dim(head + hint, ctx.color) + "\n");
+}
 function registerEnterpriseJobsList(parent) {
   parent.command("list").description("List your company job postings").option("--page <n>", "page number (server: currentPage, default 1)", (v) => Number(v)).option("--page-size <n>", "items per page (server: pageSize, default 10, max 100)", (v) => Number(v)).option("--keyword <kw>", "filter by job title keyword").option("--status <state>", "filter by status: published | unpublished").option("--fields <list>", "output selected fields as JSON (comma-separated dotted paths)").option("--minimal", `output only ${MINIMAL_LIST_FIELDS.join(",")} as JSON`).action(async (flags, command) => {
     const ctx = resolveContext(command);
-    if (flags.fields && flags.minimal) {
-      throw new CliError("Use either --fields or --minimal, not both", ExitCode.InvalidArgument);
-    }
     const globals = command.optsWithGlobals();
     const { key } = resolveApiKey(globals.apiKey);
-    const { body } = await enterpriseGet(
-      { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey: key },
-      "/jobs",
-      {
-        currentPage: flags.page,
-        pageSize: flags.pageSize,
-        keyword: flags.keyword,
-        status: mapStatusFlag(flags.status)
-      }
-    );
-    const paged = asPaginatedBody(body);
-    const projection = flags.minimal ? MINIMAL_LIST_FIELDS : flags.fields ? parseFieldsList(flags.fields) : void 0;
-    if (projection || ctx.format === "json") {
-      printJson(projection ? { ...paged, data: paged.data.map((row) => pickPaths(row, projection)) } : paged);
-      return;
-    }
-    printTable(
-      paged.data,
-      [
-        { header: "ENC_ID", value: (r) => (r.enc_id ?? "").slice(0, 14) },
-        { header: "TITLE", value: (r) => r.job_title ?? "", maxWidth: 36 },
-        { header: "STATUS", value: (r) => formatStatus(r.status) },
-        { header: "CODE", value: (r) => r.code ?? "", maxWidth: 16 },
-        { header: "UPDATED", value: (r) => formatDate2(r.updated_at), maxWidth: 12 }
-      ],
-      ctx.color
-    );
-    const head = `Showing page ${paged.currentPage}/${paged.totalPages} (${paged.data.length} of ${paged.totalCount} jobs).`;
-    const hint = paged.totalPages > paged.currentPage ? `  Next: wport enterprise jobs list --page ${paged.currentPage + 1}` : "";
-    process.stdout.write(dim(head + hint, ctx.color) + "\n");
+    await runEnterpriseJobsList(ctx, key, flags);
   });
 }
 
@@ -1449,6 +1537,67 @@ async function runJobsDelete(ctx, apiKey, encId, confirm, idempotencyKey) {
   process.stdout.write(`Deleted job: ${trimmed}
 `);
 }
+async function runJobsCopy(ctx, apiKey, encId, idempotencyKey) {
+  const trimmed = requireEncId(encId);
+  const { body } = await enterprisePost(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/jobs/${encodeURIComponent(trimmed)}/copy`,
+    {},
+    { idempotencyKey }
+  );
+  const result = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(result);
+    return;
+  }
+  process.stdout.write(`Copied job ${trimmed} \u2192 new draft: ${result.enc_id ?? "(unknown)"}
+`);
+  const incomplete = extractStringArray(result.incomplete_fields);
+  if (incomplete.length > 0) {
+    process.stdout.write(`  \u26A0 Incomplete for publish \u2014 fill before \`jobs publish\`: ${incomplete.join(", ")}
+`);
+  }
+}
+function extractStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((v) => typeof v === "string");
+}
+function registerEnterpriseJobsCopy(parent) {
+  parent.command("copy <enc_id>").description("Copy a job posting into a new unpublished draft").option("--idempotency-key <key>", "reuse across retries (default: a fresh UUID)").action(async (encId, flags, command) => {
+    const ctx = resolveContext(command);
+    const { key } = resolveApiKey(command.optsWithGlobals().apiKey);
+    await runJobsCopy(ctx, key, encId, flags.idempotencyKey ?? (0, import_node_crypto3.randomUUID)());
+  });
+}
+async function runJobsClose(ctx, apiKey, encId, confirm, idempotencyKey) {
+  if (!confirm) {
+    throw new CliError(
+      "Refusing to close without --confirm (irreversible; a closed job cannot be reopened \u2014 copy it to relist)",
+      ExitCode.InvalidArgument
+    );
+  }
+  const trimmed = requireEncId(encId);
+  const { body } = await enterprisePatch(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/jobs/${encodeURIComponent(trimmed)}/close`,
+    {},
+    { idempotencyKey }
+  );
+  const result = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(result);
+    return;
+  }
+  process.stdout.write(`Closed job: ${result.enc_id ?? trimmed}
+`);
+}
+function registerEnterpriseJobsClose(parent) {
+  parent.command("close <enc_id>").description("Close (finalize) a job posting (destructive, irreversible; requires --confirm)").option("--confirm", "confirm this irreversible close (a closed job cannot be reopened)").option("--idempotency-key <key>", "reuse across retries (default: a fresh UUID)").action(async (encId, flags, command) => {
+    const ctx = resolveContext(command);
+    const { key } = resolveApiKey(command.optsWithGlobals().apiKey);
+    await runJobsClose(ctx, key, encId, flags.confirm === true, flags.idempotencyKey ?? (0, import_node_crypto3.randomUUID)());
+  });
+}
 function registerEnterpriseJobsPublish(parent) {
   parent.command("publish <enc_id>").description("Publish a job posting").option("--idempotency-key <key>", "reuse across retries (default: a fresh UUID)").action(async (encId, flags, command) => {
     const ctx = resolveContext(command);
@@ -1530,6 +1679,8 @@ function registerEnterpriseJobsCommand(parent) {
   registerEnterpriseJobsPublish(jobs);
   registerEnterpriseJobsUnpublish(jobs);
   registerEnterpriseJobsDelete(jobs);
+  registerEnterpriseJobsCopy(jobs);
+  registerEnterpriseJobsClose(jobs);
   registerEnterpriseJobsBatch(jobs);
 }
 
@@ -1636,19 +1787,738 @@ function registerEnterpriseKeysCommand(parent) {
   registerEnterpriseKeysRotate(keys);
 }
 
+// src/commands/enterprise/company/view.ts
+var COMPANY_STATUS_LABELS = {
+  0: "not_submitted",
+  1: "pending_review",
+  2: "approved",
+  3: "rejected"
+};
+function formatCompanyStatus(status) {
+  if (status === void 0) return "";
+  return COMPANY_STATUS_LABELS[status] ?? String(status);
+}
+function formatPhone(company) {
+  const code = company.phone_code ?? void 0;
+  const number = company.phone_number ?? void 0;
+  if (!code && !number) return void 0;
+  return [code, number].filter(Boolean).join(" ");
+}
+function formatCapital(company) {
+  if (company.capital_amount === null || company.capital_amount === void 0) return void 0;
+  if (company.capital_show_status === 0) return "not displayed";
+  return String(company.capital_amount);
+}
+function formatAddress(company) {
+  return company.address ?? void 0;
+}
+var DETAIL_FIELDS2 = [
+  "name",
+  "uniform_number",
+  "status",
+  "website",
+  "phone",
+  "address",
+  "capital",
+  "logo_url"
+];
+function renderDetailLines2(company) {
+  const pad = Math.max(...DETAIL_FIELDS2.map((f) => f.length)) + 1;
+  const derived = {
+    name: company.name,
+    uniform_number: company.uniform_number ?? void 0,
+    status: formatCompanyStatus(company.status),
+    website: company.website ?? void 0,
+    phone: formatPhone(company),
+    address: formatAddress(company),
+    capital: formatCapital(company),
+    logo_url: company.logo_url ?? void 0
+  };
+  const lines = [];
+  for (const field of DETAIL_FIELDS2) {
+    const value = derived[field];
+    if (value === null || value === void 0 || value === "") continue;
+    lines.push(`${(field + ":").padEnd(pad + 1)}${sanitizeForTerminal(value)}`);
+  }
+  return lines;
+}
+async function runCompanyView(ctx, apiKey, flags) {
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/company"
+  );
+  const company = unwrapDataResponse(body);
+  if (flags.fields) {
+    printJson(pickPaths(company, parseFieldsList(flags.fields)));
+    return;
+  }
+  if (ctx.format === "json") {
+    printJson(company);
+    return;
+  }
+  process.stdout.write(renderDetailLines2(company).join("\n") + "\n");
+}
+function registerEnterpriseCompanyView(parent) {
+  parent.command("view").description("View your company information").option("--fields <list>", "output selected fields as JSON (comma-separated dotted paths)").action(async (flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runCompanyView(ctx, key, flags);
+  });
+}
+
+// src/commands/enterprise/company/update.ts
+var import_node_crypto5 = require("crypto");
+
+// src/commands/enterprise/company/types.ts
+var BASIC_FIELDS = [
+  "name",
+  "industry_category_code",
+  "phone_code",
+  "phone_number",
+  "employee_count_range_code",
+  "capital_amount",
+  "capital_show_status",
+  "website",
+  "area_code",
+  "address"
+];
+var DESCRIPTION_FIELDS = ["description", "products_services", "latest_news"];
+var FORBIDDEN_FIELDS = [
+  "uniform_number",
+  "banner_url",
+  "photo_1",
+  "photo_2",
+  "photo_3",
+  "video_1",
+  "video_2",
+  "video_3",
+  "foundation_date",
+  "representative",
+  "directors",
+  "milestones",
+  "awards",
+  "qa"
+];
+
+// src/commands/enterprise/company/update.ts
+var REQUIRED_BASIC_FIELDS = [
+  "name",
+  "industry_category_code",
+  "phone_code",
+  "phone_number",
+  "area_code",
+  "address"
+];
+var CONTRACT_REQUIRED_GET_FIELDS = [
+  "industry_category_code",
+  "area_code",
+  "employee_count_range_code",
+  "capital_amount",
+  "capital_show_status",
+  "latest_news",
+  "uniform_number"
+];
+async function buildCompanyUpdatePayloads(input, ctx, apiKey) {
+  const forbiddenFound = Object.keys(input).filter((k) => FORBIDDEN_FIELDS.includes(k));
+  if (forbiddenFound.length > 0) {
+    throw new InvalidArgumentError(`Field(s) not writable via CLI: ${forbiddenFound.join(", ")}`);
+  }
+  const writableFields = /* @__PURE__ */ new Set([...BASIC_FIELDS, ...DESCRIPTION_FIELDS]);
+  const unknownFound = Object.keys(input).filter((k) => !writableFields.has(k));
+  if (unknownFound.length > 0) {
+    throw new InvalidArgumentError(`Unknown field(s): ${unknownFound.join(", ")}`);
+  }
+  const inputHasBasicField = BASIC_FIELDS.some((f) => f in input);
+  const inputHasDescriptionField = DESCRIPTION_FIELDS.some((f) => f in input);
+  if (!inputHasBasicField && !inputHasDescriptionField) {
+    throw new InvalidArgumentError("No writable company fields provided");
+  }
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/company"
+  );
+  const current = unwrapDataResponse(body);
+  const missingContractFields = CONTRACT_REQUIRED_GET_FIELDS.filter((f) => !(f in current));
+  if (missingContractFields.length > 0) {
+    throw new CliError(
+      `Backend contract appears broken: GET /company response is missing field(s): ${missingContractFields.join(", ")}`,
+      ExitCode.ServerOrNetworkError
+    );
+  }
+  let basic = null;
+  if (inputHasBasicField) {
+    const merged = {};
+    for (const field of BASIC_FIELDS) {
+      merged[field] = field in input ? input[field] : current[field];
+    }
+    const missingRequired = REQUIRED_BASIC_FIELDS.filter((f) => {
+      const v = merged[f];
+      return v === null || v === void 0 || v === "";
+    });
+    if (missingRequired.length > 0) {
+      const [first] = missingRequired;
+      throw new InvalidArgumentError(
+        `Missing required field '${first}' \u2014 not provided in input and not present on your current company profile` + (missingRequired.length > 1 ? ` (also missing: ${missingRequired.slice(1).join(", ")})` : "")
+      );
+    }
+    basic = merged;
+  }
+  let descriptions = null;
+  if (inputHasDescriptionField) {
+    descriptions = {};
+    for (const field of DESCRIPTION_FIELDS) {
+      if (field in input) descriptions[field] = input[field];
+    }
+  }
+  return { basic, descriptions };
+}
+function isDescriptionsPartialFailureBody(body) {
+  return !!body && typeof body === "object" && Array.isArray(body.updated_sections) && typeof body.failed_section === "string";
+}
+function printCompanyResult(company, format) {
+  if (format === "json") {
+    printJson(company);
+    return;
+  }
+  process.stdout.write(`Updated company: ${company.name ?? ""}
+`);
+}
+function resolveUpdateIdempotencyKeys(needsBasic, needsDescriptions, flags) {
+  const bothNeeded = needsBasic && needsDescriptions;
+  if (bothNeeded && flags.idempotencyKey !== void 0) {
+    throw new InvalidArgumentError(
+      "Both basic and descriptions sections changed: use --basic-idempotency-key and --descriptions-idempotency-key instead of --idempotency-key, to avoid reusing the same key for two different payloads"
+    );
+  }
+  return {
+    basicKey: needsBasic ? flags.basicIdempotencyKey ?? flags.idempotencyKey ?? (0, import_node_crypto5.randomUUID)() : void 0,
+    descriptionsKey: needsDescriptions ? flags.descriptionsIdempotencyKey ?? flags.idempotencyKey ?? (0, import_node_crypto5.randomUUID)() : void 0
+  };
+}
+async function runCompanyUpdate(ctx, apiKey, source, idempotencyFlags, options = {}) {
+  const input = readJsonObject(source, options);
+  const needsBasic = BASIC_FIELDS.some((f) => f in input);
+  const needsDescriptions = DESCRIPTION_FIELDS.some((f) => f in input);
+  const { basicKey, descriptionsKey } = resolveUpdateIdempotencyKeys(needsBasic, needsDescriptions, idempotencyFlags);
+  const payloads = await buildCompanyUpdatePayloads(input, ctx, apiKey);
+  const requestOpts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey };
+  let basicResultCompany;
+  if (needsBasic) {
+    const { body } = await enterprisePatch(requestOpts, "/company/basic", payloads.basic, {
+      idempotencyKey: basicKey
+    });
+    basicResultCompany = unwrapDataResponse(body);
+  }
+  if (!needsDescriptions) {
+    printCompanyResult(basicResultCompany, ctx.format);
+    return;
+  }
+  try {
+    const { body } = await enterprisePatch(
+      requestOpts,
+      "/company/descriptions",
+      payloads.descriptions,
+      { idempotencyKey: descriptionsKey }
+    );
+    const result = unwrapDataResponse(body);
+    printCompanyResult(result.company, ctx.format);
+  } catch (err) {
+    if (!needsBasic) {
+      throw err;
+    }
+    const descriptionsBody = err instanceof ServerClientHttpError ? err.body : void 0;
+    const partial = isDescriptionsPartialFailureBody(descriptionsBody) ? descriptionsBody : void 0;
+    if (ctx.format === "json") {
+      printJson({
+        basic_updated: true,
+        basic_company: basicResultCompany,
+        descriptions_error: partial ? { updated_sections: partial.updated_sections, failed_section: partial.failed_section } : { message: err instanceof Error ? err.message : String(err) }
+      });
+    } else {
+      process.stdout.write("Basic company info was updated successfully.\n");
+      if (partial) {
+        process.stdout.write(
+          `Updated sections before failure: ${(partial.updated_sections ?? []).join(", ")}; failed section: ${partial.failed_section}
+`
+        );
+      } else {
+        process.stdout.write(
+          `Descriptions update failed entirely: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+    throw err;
+  }
+}
+function registerEnterpriseCompanyUpdate(parent) {
+  parent.command("update").description(
+    "Update your company basic info and/or descriptions from a JSON file (uniform_number is read-only and cannot be changed via this command)"
+  ).requiredOption("--file <path>", 'path to a partial JSON company body, or "-" for stdin').option("--idempotency-key <key>", "single-section update only: reuse across retries (default: a fresh UUID)").option("--basic-idempotency-key <key>", "two-section update: idempotency key for PATCH /company/basic").option(
+    "--descriptions-idempotency-key <key>",
+    "two-section update: idempotency key for PATCH /company/descriptions"
+  ).action(async (flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runCompanyUpdate(
+      ctx,
+      key,
+      flags.file,
+      {
+        idempotencyKey: flags.idempotencyKey,
+        basicIdempotencyKey: flags.basicIdempotencyKey,
+        descriptionsIdempotencyKey: flags.descriptionsIdempotencyKey
+      },
+      { timeoutMs: ctx.timeoutMs }
+    );
+  });
+}
+
+// src/commands/enterprise/company/logo.ts
+var import_node_crypto6 = require("crypto");
+var import_node_fs7 = require("fs");
+var import_node_path3 = require("path");
+var EXTENSION_TO_CONTENT_TYPE = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg"
+};
+var COMPANY_LOGO_MAX_SIZE = 2 * 1024 * 1024;
+function inspectLocalFile(path) {
+  if (!(0, import_node_fs7.existsSync)(path)) {
+    throw new InvalidArgumentError(`File not found: ${path}`);
+  }
+  const stat = (0, import_node_fs7.statSync)(path);
+  if (!stat.isFile()) {
+    throw new InvalidArgumentError(`Not a regular file: ${path}`);
+  }
+  const ext = (0, import_node_path3.extname)(path).toLowerCase();
+  const contentType = EXTENSION_TO_CONTENT_TYPE[ext];
+  if (!contentType) {
+    throw new InvalidArgumentError(
+      `Unsupported file extension "${ext || "(none)"}" \u2014 allowed: ${Object.keys(EXTENSION_TO_CONTENT_TYPE).join(", ")}`
+    );
+  }
+  if (stat.size <= 0) {
+    throw new InvalidArgumentError(`File is empty: ${path}`);
+  }
+  if (stat.size > COMPANY_LOGO_MAX_SIZE) {
+    throw new InvalidArgumentError(`File too large: ${stat.size} bytes (max ${COMPANY_LOGO_MAX_SIZE} bytes / 2MB)`);
+  }
+  const bytes = (0, import_node_fs7.readFileSync)(path);
+  return { contentType, fileSize: stat.size, bytes };
+}
+function resolveLogoIdempotencyKeys(flags) {
+  if (flags.idempotencyKey) {
+    return {
+      presignKey: `${flags.idempotencyKey}-presign`,
+      confirmKey: `${flags.idempotencyKey}-confirm`
+    };
+  }
+  return { presignKey: (0, import_node_crypto6.randomUUID)(), confirmKey: (0, import_node_crypto6.randomUUID)() };
+}
+function printLogoResult(result, format) {
+  if (format === "json") {
+    printJson(result);
+    return;
+  }
+  process.stdout.write(`Updated logo: ${result.logo_url}
+`);
+}
+async function runCompanyLogoUpload(ctx, apiKey, path, idempotencyFlags) {
+  const { contentType, fileSize, bytes } = inspectLocalFile(path);
+  const { presignKey, confirmKey } = resolveLogoIdempotencyKeys(idempotencyFlags);
+  const requestOpts = { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey };
+  const { body: presignBody } = await enterprisePost(
+    requestOpts,
+    "/company/logo/presign",
+    { content_type: contentType, file_size: fileSize },
+    { idempotencyKey: presignKey }
+  );
+  const presign = unwrapDataResponse(presignBody);
+  const putRequest = new Request(presign.upload_url, {
+    method: "PUT",
+    headers: { "Content-Type": contentType },
+    body: bytes
+  });
+  const putResponse = await fetchWithTimeout(putRequest, ctx.timeoutMs);
+  if (!putResponse.ok) {
+    throw new NetworkError(`Failed to upload file to S3: HTTP ${putResponse.status}`);
+  }
+  const { body: confirmBody } = await enterprisePost(
+    requestOpts,
+    "/company/logo/confirm",
+    { s3_key: presign.s3_key },
+    { idempotencyKey: confirmKey }
+  );
+  const result = unwrapDataResponse(confirmBody);
+  printLogoResult(result, ctx.format);
+}
+function registerEnterpriseCompanyLogo(parent) {
+  const logo = parent.command("logo").description("Manage your company logo");
+  logo.command("upload <path>").description("Upload and set your company logo (presign + upload + confirm)").option("--idempotency-key <key>", "base key for presign/confirm (each derives its own; default: fresh UUIDs)").action(async (path, flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runCompanyLogoUpload(ctx, key, path, { idempotencyKey: flags.idempotencyKey });
+  });
+}
+
+// src/commands/enterprise/company/index.ts
+function registerEnterpriseCompanyCommand(parent) {
+  const company = parent.command("company").description("View and manage your company information");
+  registerEnterpriseCompanyView(company);
+  registerEnterpriseCompanyUpdate(company);
+  registerEnterpriseCompanyLogo(company);
+}
+
+// src/commands/enterprise/talents/list.ts
+var DEFAULT_PAGE_SIZE = 20;
+var MINIMAL_LIST_FIELDS2 = ["enc_resume_id", "candidate_name", "applied_job_title", "applied_at"];
+function formatDate4(value) {
+  return value ? String(value).slice(0, 10) : "";
+}
+async function runEnterpriseTalentsList(ctx, apiKey, flags) {
+  if (flags.fields && flags.minimal) {
+    throw new CliError("Use either --fields or --minimal, not both", ExitCode.InvalidArgument);
+  }
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/talents",
+    {
+      tab: flags.tab,
+      enc_job_id: flags.job,
+      keyword: flags.keyword,
+      start_date: flags.from,
+      end_date: flags.to,
+      currentPage: flags.page,
+      pageSize: flags.pageSize ?? DEFAULT_PAGE_SIZE
+    }
+  );
+  const paged = asPaginatedBody(body);
+  const projection = flags.minimal ? MINIMAL_LIST_FIELDS2 : flags.fields ? parseFieldsList(flags.fields) : void 0;
+  if (projection || ctx.format === "json") {
+    printJson(projection ? { ...paged, data: paged.data.map((row) => pickPaths(row, projection)) } : paged);
+    return;
+  }
+  printTable(
+    paged.data,
+    [
+      { header: "RESUME_ID", value: (r) => (r.enc_resume_id ?? "").slice(0, 14) },
+      { header: "CANDIDATE", value: (r) => r.candidate_name ?? "", maxWidth: 20 },
+      { header: "EDUCATION", value: (r) => r.highest_education ?? "", maxWidth: 18 },
+      { header: "EXPERIENCE", value: (r) => r.latest_experience ?? "", maxWidth: 28 },
+      { header: "APPLIED_JOB", value: (r) => r.applied_job_title ?? "", maxWidth: 24 },
+      { header: "APPLIED_AT", value: (r) => formatDate4(r.applied_at), maxWidth: 12 },
+      { header: "VIEWED", value: (r) => r.is_viewed ? "yes" : "no" }
+    ],
+    ctx.color
+  );
+  const head = `Showing page ${paged.currentPage}/${paged.totalPages} (${paged.data.length} of ${paged.totalCount} applicants).`;
+  const hint = paged.totalPages > paged.currentPage ? `  Next: wport enterprise talents list --page ${paged.currentPage + 1}` : "";
+  process.stdout.write(dim(head + hint, ctx.color) + "\n");
+}
+function registerEnterpriseTalentsList(parent) {
+  parent.command("list").description("List applicants in your talent pool").option("--tab <tab>", "applied | visit (default applied; visit is not yet supported by the server)").option("--job <enc_job_id>", "filter by job posting enc_id").option("-k, --keyword <kw>", "filter by candidate name keyword").option("--from <date>", "applied on/after this date (YYYY-MM-DD)").option("--to <date>", "applied on/before this date (YYYY-MM-DD)").option("-p, --page <n>", "page number (server: currentPage, default 1)", (v) => Number(v)).option("-s, --page-size <n>", `items per page (default ${DEFAULT_PAGE_SIZE}, max 100)`, (v) => Number(v)).option("--fields <list>", "output selected fields as JSON (comma-separated dotted paths)").option("--minimal", `output only ${MINIMAL_LIST_FIELDS2.join(",")} as JSON`).action(async (flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runEnterpriseTalentsList(ctx, key, flags);
+  });
+}
+
+// src/commands/enterprise/talents/view.ts
+async function runEnterpriseTalentsView(ctx, apiKey, encResumeId, flags) {
+  const trimmed = encResumeId.trim();
+  if (!trimmed) {
+    throw new CliError("enc_resume_id must not be empty", ExitCode.InvalidArgument);
+  }
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/talents/${encodeURIComponent(trimmed)}`
+  );
+  const resume = unwrapDataResponse(body);
+  if (flags.fields) {
+    printJson(pickPaths(resume, parseFieldsList(flags.fields)));
+    return;
+  }
+  printJson(resume);
+}
+function registerEnterpriseTalentsView(parent) {
+  parent.command("view <enc_resume_id>").description("View one applicant resume preview (company-scoped; PII visibility per access level)").option("--fields <list>", "output selected fields as JSON (comma-separated dotted paths)").action(async (encResumeId, flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runEnterpriseTalentsView(ctx, key, encResumeId, flags);
+  });
+}
+
+// src/commands/enterprise/talents/respond.ts
+var import_node_crypto7 = require("crypto");
+function resolveRespondBody(flags, options = {}) {
+  const hasBody = flags.body !== void 0;
+  const hasBodyFile = flags.bodyFile !== void 0;
+  if (hasBody === hasBodyFile) {
+    throw new CliError("Provide exactly one of --body or --body-file", ExitCode.InvalidArgument);
+  }
+  if (hasBody) {
+    if (!flags.body.trim()) throw new CliError("--body must not be empty", ExitCode.InvalidArgument);
+    return flags.body;
+  }
+  return readTextInput(flags.bodyFile, { timeoutMs: options.timeoutMs });
+}
+async function runEnterpriseTalentsRespond(ctx, apiKey, encResumeId, flags, idempotencyKey) {
+  const trimmedId = encResumeId.trim();
+  if (!trimmedId) {
+    throw new CliError("enc_resume_id must not be empty", ExitCode.InvalidArgument);
+  }
+  const subject = (flags.subject ?? "").trim();
+  if (!subject) {
+    throw new CliError("--subject is required and must not be empty", ExitCode.InvalidArgument);
+  }
+  const body = resolveRespondBody(flags, { timeoutMs: ctx.timeoutMs });
+  const encJobId = flags.encJobId?.trim();
+  const payload = { subject, body };
+  if (encJobId) payload.enc_job_id = encJobId;
+  const { body: respBody } = await enterprisePost(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/talents/${encodeURIComponent(trimmedId)}/respond`,
+    payload,
+    { idempotencyKey }
+  );
+  const result = unwrapDataResponse(respBody);
+  if (ctx.format === "json") {
+    printJson(result);
+    return;
+  }
+  process.stdout.write(`Replied to ${result.enc_resume_id ?? trimmedId}; sent at ${result.sent_at ?? "(unknown)"}.
+`);
+}
+function registerEnterpriseTalentsRespond(parent) {
+  parent.command("respond <enc_resume_id>").description("Reply to an applicant (in-app message; inherits the company daily reply quota)").requiredOption("--subject <subject>", "message subject (max 200)").option("--body <text>", "message body text (max 5000)").option("--body-file <path>", 'read message body from a file, or "-" for stdin').option("--enc-job-id <enc_id>", "reply to a specific job posting; omit to reply to the most recent application").option("--idempotency-key <key>", "reuse across retries to avoid duplicate sends (default: a fresh UUID)").action(async (encResumeId, flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runEnterpriseTalentsRespond(ctx, key, encResumeId, flags, flags.idempotencyKey ?? (0, import_node_crypto7.randomUUID)());
+  });
+}
+
+// src/commands/enterprise/talents/index.ts
+function registerEnterpriseTalentsCommand(parent) {
+  const talents = parent.command("talents").description(
+    "Browse & respond to your applied talent pool (visit tab n/a, no active candidate search \u2014 see `wport doctor`)"
+  );
+  registerEnterpriseTalentsList(talents);
+  registerEnterpriseTalentsView(talents);
+  registerEnterpriseTalentsRespond(talents);
+}
+
+// src/commands/enterprise/campaigns/create.ts
+var import_node_crypto8 = require("crypto");
+async function runCampaignCreate(ctx, apiKey, source, idempotencyKey) {
+  const campaignBody = readJsonObject(source, { timeoutMs: ctx.timeoutMs });
+  const { body } = await enterprisePost(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/campaigns",
+    campaignBody,
+    { idempotencyKey }
+  );
+  const created = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(created);
+    return;
+  }
+  process.stdout.write(`Created campaign: ${created.enc_id ?? ""}
+`);
+}
+function registerEnterpriseCampaignsCreate(parent) {
+  parent.command("create").description('Create a recruitment campaign from a JSON file (use "-" to read stdin)').requiredOption("--file <path>", 'path to a JSON campaign body, or "-" for stdin').option("--idempotency-key <key>", "reuse across retries to avoid duplicate creates (default: a fresh UUID)").action(async (flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runCampaignCreate(ctx, key, flags.file, flags.idempotencyKey ?? (0, import_node_crypto8.randomUUID)());
+  });
+}
+
+// src/commands/enterprise/campaigns/list.ts
+var STATUS_MAP2 = { open: 1, closed: 0 };
+var MINIMAL_LIST_FIELDS3 = ["enc_id", "name", "status", "job_count"];
+function mapStatusFlag2(raw) {
+  if (raw === void 0) return void 0;
+  if (Object.prototype.hasOwnProperty.call(STATUS_MAP2, raw)) return STATUS_MAP2[raw];
+  throw new CliError(`Invalid --status "${raw}". Allowed: ${Object.keys(STATUS_MAP2).join(", ")}`, ExitCode.InvalidArgument);
+}
+function formatStatus2(status) {
+  if (status === 1) return "open";
+  if (status === 0) return "closed";
+  return status === void 0 ? "" : String(status);
+}
+function formatCount2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : "\u2014";
+}
+async function runEnterpriseCampaignsList(ctx, apiKey, flags) {
+  if (flags.fields && flags.minimal) {
+    throw new CliError("Use either --fields or --minimal, not both", ExitCode.InvalidArgument);
+  }
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/campaigns",
+    {
+      currentPage: flags.page,
+      pageSize: flags.pageSize,
+      keyword: flags.keyword,
+      status: mapStatusFlag2(flags.status)
+    }
+  );
+  const paged = asPaginatedBody(body);
+  const projection = flags.minimal ? MINIMAL_LIST_FIELDS3 : flags.fields ? parseFieldsList(flags.fields) : void 0;
+  if (projection || ctx.format === "json") {
+    printJson(projection ? { ...paged, data: paged.data.map((row) => pickPaths(row, projection)) } : paged);
+    return;
+  }
+  printTable(
+    paged.data,
+    [
+      { header: "ENC_ID", value: (r) => (r.enc_id ?? "").slice(0, 14) },
+      { header: "NAME", value: (r) => r.name ?? "", maxWidth: 32 },
+      { header: "STATUS", value: (r) => formatStatus2(r.status) },
+      { header: "JOBS", value: (r) => formatCount2(r.job_count) },
+      { header: "PV", value: (r) => formatCount2(r.pv) },
+      { header: "VISITORS", value: (r) => formatCount2(r.visitors_count) }
+    ],
+    ctx.color
+  );
+  const head = `Showing page ${paged.currentPage}/${paged.totalPages} (${paged.data.length} of ${paged.totalCount} campaigns).`;
+  const hint = paged.totalPages > paged.currentPage ? `  Next: wport enterprise campaigns list --page ${paged.currentPage + 1}` : "";
+  process.stdout.write(dim(head + hint, ctx.color) + "\n");
+}
+function registerEnterpriseCampaignsList(parent) {
+  parent.command("list").description("List your recruitment campaigns").option("-p, --page <n>", "page number (server: currentPage, default 1)", (v) => Number(v)).option("-s, --page-size <n>", "items per page (default 10, max 100)", (v) => Number(v)).option("-k, --keyword <kw>", "filter by campaign name keyword").option("--status <state>", "filter by status: open | closed").option("--fields <list>", "output selected fields as JSON (comma-separated dotted paths)").option("--minimal", `output only ${MINIMAL_LIST_FIELDS3.join(",")} as JSON`).action(async (flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runEnterpriseCampaignsList(ctx, key, flags);
+  });
+}
+
+// src/commands/enterprise/campaigns/lifecycle.ts
+var import_node_crypto9 = require("crypto");
+async function runCampaignTransition(ctx, apiKey, encId, action, idempotencyKey) {
+  const trimmed = requireEncId(encId);
+  const { body } = await enterprisePatch(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/campaigns/${encodeURIComponent(trimmed)}/${action}`,
+    {},
+    { idempotencyKey }
+  );
+  const result = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(result);
+    return;
+  }
+  const verb = action === "publish" ? "Published" : "Unpublished";
+  process.stdout.write(`${verb} campaign: ${result.enc_id ?? trimmed}
+`);
+}
+function registerEnterpriseCampaignsPublish(parent) {
+  parent.command("publish <enc_id>").description("Publish (activate) a recruitment campaign").option("--idempotency-key <key>", "reuse across retries (default: a fresh UUID)").action(async (encId, flags, command) => {
+    const ctx = resolveContext(command);
+    const { key } = resolveApiKey(command.optsWithGlobals().apiKey);
+    await runCampaignTransition(ctx, key, encId, "publish", flags.idempotencyKey ?? (0, import_node_crypto9.randomUUID)());
+  });
+}
+function registerEnterpriseCampaignsUnpublish(parent) {
+  parent.command("unpublish <enc_id>").description("Unpublish (deactivate) a recruitment campaign").option("--idempotency-key <key>", "reuse across retries (default: a fresh UUID)").action(async (encId, flags, command) => {
+    const ctx = resolveContext(command);
+    const { key } = resolveApiKey(command.optsWithGlobals().apiKey);
+    await runCampaignTransition(ctx, key, encId, "unpublish", flags.idempotencyKey ?? (0, import_node_crypto9.randomUUID)());
+  });
+}
+
+// src/commands/enterprise/campaigns/update.ts
+var import_node_crypto10 = require("crypto");
+async function runCampaignUpdate(ctx, apiKey, encId, source, idempotencyKey) {
+  const trimmed = requireEncId(encId);
+  const campaignBody = readJsonObject(source, { timeoutMs: ctx.timeoutMs });
+  const { body } = await enterprisePatch(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/campaigns/${encodeURIComponent(trimmed)}`,
+    campaignBody,
+    { idempotencyKey }
+  );
+  const updated = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(updated);
+    return;
+  }
+  process.stdout.write(`Updated campaign: ${updated.enc_id ?? trimmed}
+`);
+}
+function registerEnterpriseCampaignsUpdate(parent) {
+  parent.command("update <enc_id>").description('Update a recruitment campaign from a JSON file (use "-" to read stdin)').requiredOption("--file <path>", 'path to a partial JSON campaign body, or "-" for stdin').option("--idempotency-key <key>", "reuse across retries (default: a fresh UUID)").action(async (encId, flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runCampaignUpdate(ctx, key, encId, flags.file, flags.idempotencyKey ?? (0, import_node_crypto10.randomUUID)());
+  });
+}
+
+// src/commands/enterprise/campaigns/view.ts
+async function runEnterpriseCampaignsView(ctx, apiKey, encId, flags) {
+  const trimmed = encId.trim();
+  if (!trimmed) {
+    throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  }
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/campaigns/${encodeURIComponent(trimmed)}`
+  );
+  const campaign = unwrapDataResponse(body);
+  if (flags.fields) {
+    printJson(pickPaths(campaign, parseFieldsList(flags.fields)));
+    return;
+  }
+  printJson(campaign);
+}
+function registerEnterpriseCampaignsView(parent) {
+  parent.command("view <enc_id>").description("View one recruitment campaign (with its jobs)").option("--fields <list>", "output selected fields as JSON (comma-separated dotted paths)").action(async (encId, flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runEnterpriseCampaignsView(ctx, key, encId, flags);
+  });
+}
+
+// src/commands/enterprise/campaigns/index.ts
+function registerEnterpriseCampaignsCommand(parent) {
+  const campaigns = parent.command("campaigns").description("Manage your recruitment campaigns");
+  registerEnterpriseCampaignsList(campaigns);
+  registerEnterpriseCampaignsView(campaigns);
+  registerEnterpriseCampaignsCreate(campaigns);
+  registerEnterpriseCampaignsUpdate(campaigns);
+  registerEnterpriseCampaignsPublish(campaigns);
+  registerEnterpriseCampaignsUnpublish(campaigns);
+}
+
 // src/commands/enterprise/index.ts
 function registerEnterpriseCommand(program2) {
   const enterprise = program2.command("enterprise").description("Manage your company job postings with an enterprise API key").option("--api-key <key>", 'one-off API key (prefer "wport enterprise login" or the WPORT_API_KEY env var)');
   registerEnterpriseLogin(enterprise);
   registerEnterpriseLogout(enterprise);
   registerEnterpriseWhoami(enterprise);
+  registerEnterpriseUsage(enterprise);
   registerEnterpriseJobsCommand(enterprise);
   registerEnterpriseKeysCommand(enterprise);
+  registerEnterpriseCompanyCommand(enterprise);
+  registerEnterpriseTalentsCommand(enterprise);
+  registerEnterpriseCampaignsCommand(enterprise);
 }
 
 // src/index.ts
 var program = new import_commander.Command();
-program.name("wport").description("wport CLI \u2014 terminal interface to the W101 Talent Search Hub public API").version("0.4.0", "-v, --version", "output the CLI version").option("--lang <locale>", "Accept-Language locale: zh-TW | en-US | vi-VN | th-TH | id-ID").option("--api <url>", "override API base URL").option("--output <fmt>", "output format: table | json").option("--no-color", "disable color output").option("--timeout <ms>", "HTTP timeout in milliseconds", (v) => Number(v));
+program.name("wport").description("wport CLI \u2014 terminal interface to the W101 Talent Search Hub public API").version("0.6.0", "-v, --version", "output the CLI version").option("--lang <locale>", "Accept-Language locale: zh-TW | en-US | vi-VN | th-TH | id-ID").option("--api <url>", "override API base URL").option("--output <fmt>", "output format: table | json").option("--no-color", "disable color output").option("--timeout <ms>", "HTTP timeout in milliseconds", (v) => Number(v));
 registerJobsCommand(program);
 registerConfigCommand(program);
 registerDoctorCommand(program);