@wport/cli 0.2.2 → 0.5.0

package/dist/index.js

@@ -179,7 +179,7 @@ function isTimeoutAbort(err) {
   return false;
 }
 function buildUserAgent() {
-  return `wport-cli/${"0.2.2"} (node ${process.version}; ${process.platform})`;
+  return `wport-cli/${"0.5.0"} (node ${process.version}; ${process.platform})`;
 }
 function unwrapDataResponse(body) {
   if (body && typeof body === "object" && "success" in body && "data" in body) {
@@ -187,6 +187,13 @@ function unwrapDataResponse(body) {
   }
   throw new CliError("Unexpected response shape: missing { success, data } wrapper", ExitCode.ServerOrNetworkError);
 }
+function unwrapDataArray(body) {
+  const data = unwrapDataResponse(body);
+  if (!Array.isArray(data)) {
+    throw new CliError("Unexpected response shape: `data` is not an array", ExitCode.ServerOrNetworkError);
+  }
+  return data;
+}
 function asPaginatedBody(body) {
   if (!body || typeof body !== "object") {
     throw new CliError("Unexpected response shape: not an object", ExitCode.ServerOrNetworkError);
@@ -633,6 +640,57 @@ function promptSecret(promptText, options = {}) {
     stdin.on("data", onData);
   });
 }
+function readJsonInput(source, options = {}) {
+  const readStdin = options.readStdin ?? ((label) => readPipedStdin(label, { timeoutMs: options.timeoutMs }));
+  let raw;
+  if (source === "-") {
+    raw = readStdin("--file -");
+  } else {
+    try {
+      raw = (0, import_node_fs3.readFileSync)(source, "utf8");
+    } catch (err) {
+      throw new InvalidArgumentError(
+        `Cannot read --file "${source}": ${err.code ?? err.message}`
+      );
+    }
+  }
+  if (!raw.trim()) {
+    throw new InvalidArgumentError("Input is empty \u2014 expected a JSON body");
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    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)) {
+    throw new InvalidArgumentError(
+      `Input must be a JSON object, got ${Array.isArray(parsed) ? "an array" : typeof parsed}`
+    );
+  }
+  return parsed;
+}
 
 // src/commands/jobs/view.ts
 var import_picocolors2 = __toESM(require("picocolors"));
@@ -920,7 +978,7 @@ function registerDoctorCommand(program2) {
   ).action(async (_opts, command) => {
     const ctx = resolveContext(command);
     const line = (s = "") => process.stdout.write(s + "\n");
-    line(`wport-cli ${"0.2.2"}`);
+    line(`wport-cli ${"0.5.0"}`);
     line(`  bundled schema fingerprint: ${"839e8a891dfb"}`);
     line("");
     line("Resolved configuration:");
@@ -984,19 +1042,48 @@ async function enterpriseGet(opts, path, query) {
   warnIfRateLimitLow(res.headers);
   return { body, headers: res.headers };
 }
+async function enterpriseWrite(method, opts, path, body, extra) {
+  const url = new URL(`${opts.baseUrl}${ENTERPRISE_PREFIX}${path}`);
+  const headers = {
+    Authorization: `Bearer ${opts.apiKey}`,
+    "Accept-Language": opts.locale,
+    "User-Agent": buildUserAgent(),
+    Accept: "application/json"
+  };
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  if (extra?.idempotencyKey) headers["Idempotency-Key"] = extra.idempotencyKey;
+  if (extra?.ifMatch) headers["If-Match"] = extra.ifMatch;
+  const request = new Request(url, {
+    method,
+    headers,
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  const res = await fetchWithTimeout(request, opts.timeoutMs);
+  const respBody = await res.json().catch(() => null);
+  if (!res.ok) throwEnterpriseHttpError(res.status, respBody);
+  warnIfRateLimitLow(res.headers);
+  return { body: respBody, headers: res.headers };
+}
+function enterprisePost(opts, path, body, extra) {
+  return enterpriseWrite("POST", opts, path, body, extra);
+}
+function enterprisePatch(opts, path, body, extra) {
+  return enterpriseWrite("PATCH", opts, path, body, extra);
+}
+function enterpriseDelete(opts, path, extra) {
+  return enterpriseWrite("DELETE", opts, path, void 0, extra);
+}
 function throwEnterpriseHttpError(status, body) {
   const base = extractErrorMessage(body) ?? `HTTP ${status}`;
   if (status === 401) {
     throw new CliError(
-      `${base}
-Key may have been revoked \u2014 run \`wport enterprise login\` to re-authenticate.`,
+      `${base} \u2014 If your key has expired, rotate it in place: \`wport enterprise keys rotate <enc_id>\` (an expired key is still accepted for rotate). If it was revoked or is incorrect, obtain a valid key and run \`wport enterprise login\`.`,
       ExitCode.ServerClientError
     );
   }
   if (status === 403) {
     throw new CliError(
-      `${base}
-If your company account has been suspended, please contact support.`,
+      `${base} \u2014 Your key may lack the required scope; rotate or issue a key that includes it. If your company account has been suspended, please contact support.`,
       ExitCode.ServerClientError
     );
   }
@@ -1183,6 +1270,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"];
@@ -1202,44 +1324,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);
   });
 }
 
@@ -1281,11 +1410,1055 @@ function registerEnterpriseJobsView(parent) {
   });
 }
 
+// src/commands/enterprise/jobs/create.ts
+var import_node_crypto = require("crypto");
+async function runJobsCreate(ctx, apiKey, source, idempotencyKey) {
+  const jobBody = readJsonObject(source, { timeoutMs: ctx.timeoutMs });
+  const { body } = await enterprisePost(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/jobs",
+    jobBody,
+    { idempotencyKey }
+  );
+  const created = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(created);
+    return;
+  }
+  process.stdout.write(`Created job: ${created.enc_id ?? ""}
+`);
+}
+function registerEnterpriseJobsCreate(parent) {
+  parent.command("create").description('Create a job posting from a JSON file (use "-" to read stdin)').requiredOption("--file <path>", 'path to a JSON job 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 runJobsCreate(ctx, key, flags.file, flags.idempotencyKey ?? (0, import_node_crypto.randomUUID)());
+  });
+}
+
+// src/commands/enterprise/jobs/update.ts
+var import_node_crypto2 = require("crypto");
+
+// src/commands/enterprise/jobs/write-shared.ts
+function requireEncId(encId) {
+  const trimmed = encId.trim();
+  if (!trimmed) throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  return trimmed;
+}
+
+// src/commands/enterprise/jobs/update.ts
+async function runJobsUpdate(ctx, apiKey, encId, source, idempotencyKey, ifMatch) {
+  const trimmed = requireEncId(encId);
+  const jobBody = readJsonObject(source, { timeoutMs: ctx.timeoutMs });
+  const { body } = await enterprisePatch(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/jobs/${encodeURIComponent(trimmed)}`,
+    jobBody,
+    { idempotencyKey, ifMatch }
+  );
+  const updated = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(updated);
+    return;
+  }
+  process.stdout.write(`Updated job: ${updated.enc_id ?? trimmed}
+`);
+}
+function registerEnterpriseJobsUpdate(parent) {
+  parent.command("update <enc_id>").description('Update a job posting from a JSON file (partial; use "-" for stdin)').requiredOption("--file <path>", 'path to a partial JSON job body, or "-" for stdin').option("--if-match <updated_at>", "optimistic lock: the job's current updated_at (409 if stale)").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 runJobsUpdate(ctx, key, encId, flags.file, flags.idempotencyKey ?? (0, import_node_crypto2.randomUUID)(), flags.ifMatch);
+  });
+}
+
+// src/commands/enterprise/jobs/lifecycle.ts
+var import_node_crypto3 = require("crypto");
+async function runJobsTransition(ctx, apiKey, encId, action, idempotencyKey) {
+  const trimmed = requireEncId(encId);
+  const { body } = await enterprisePatch(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/jobs/${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} job: ${result.enc_id ?? trimmed}
+`);
+}
+async function runJobsDelete(ctx, apiKey, encId, confirm, idempotencyKey) {
+  if (!confirm) {
+    throw new CliError("Refusing to delete without --confirm (destructive, irreversible)", ExitCode.InvalidArgument);
+  }
+  const trimmed = requireEncId(encId);
+  await enterpriseDelete(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/jobs/${encodeURIComponent(trimmed)}`,
+    { idempotencyKey }
+  );
+  if (ctx.format === "json") {
+    printJson({ enc_id: trimmed, deleted: true });
+    return;
+  }
+  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)"}
+`);
+}
+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);
+    const { key } = resolveApiKey(command.optsWithGlobals().apiKey);
+    await runJobsTransition(ctx, key, encId, "publish", flags.idempotencyKey ?? (0, import_node_crypto3.randomUUID)());
+  });
+}
+function registerEnterpriseJobsUnpublish(parent) {
+  parent.command("unpublish <enc_id>").description("Unpublish (take down) a job posting").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 runJobsTransition(ctx, key, encId, "unpublish", flags.idempotencyKey ?? (0, import_node_crypto3.randomUUID)());
+  });
+}
+function registerEnterpriseJobsDelete(parent) {
+  parent.command("delete <enc_id>").description("Delete a job posting (destructive; requires --confirm)").option("--confirm", "confirm this destructive, irreversible delete").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 runJobsDelete(ctx, key, encId, flags.confirm === true, flags.idempotencyKey ?? (0, import_node_crypto3.randomUUID)());
+  });
+}
+
+// src/commands/enterprise/jobs/batch.ts
+var import_node_crypto4 = require("crypto");
+var BATCH_MIN = 1;
+var BATCH_MAX = 10;
+async function runJobsBatch(ctx, apiKey, source, confirm, idempotencyKey) {
+  if (!confirm) {
+    throw new CliError("Refusing to run batch create without --confirm", ExitCode.InvalidArgument);
+  }
+  const payload = readJsonObject(source, { timeoutMs: ctx.timeoutMs });
+  const jobs = payload.jobs;
+  if (!Array.isArray(jobs) || jobs.length < BATCH_MIN || jobs.length > BATCH_MAX) {
+    throw new CliError(
+      `Batch input must be { "jobs": [...] } with ${BATCH_MIN} to ${BATCH_MAX} items`,
+      ExitCode.InvalidArgument
+    );
+  }
+  const { body } = await enterprisePost(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/jobs/batch",
+    payload,
+    { idempotencyKey }
+  );
+  const result = unwrapDataResponse(body);
+  const succeeded = result.succeeded ?? [];
+  const failed = result.failed ?? [];
+  if (ctx.format === "json") {
+    printJson(result);
+  } else {
+    process.stdout.write(`Batch: ${succeeded.length} succeeded, ${failed.length} failed (of ${jobs.length}).
+`);
+    for (const s of succeeded)
+      process.stdout.write(`  ok   [${s.index}] ${sanitizeForTerminal(String(s.enc_id ?? ""))}
+`);
+    for (const f of failed)
+      process.stdout.write(`  fail [${f.index}] ${sanitizeForTerminal(String(f.error_path ?? ""))}
+`);
+  }
+  if (failed.length > 0) {
+    throw new CliError(`${failed.length} of ${jobs.length} job(s) failed in batch create`, ExitCode.ServerClientError);
+  }
+}
+function registerEnterpriseJobsBatch(parent) {
+  parent.command("batch").description('Batch-create up to 10 jobs from a JSON file ({ "jobs": [...] }; requires --confirm)').requiredOption("--file <path>", 'path to a JSON { "jobs": [...] } body, or "-" for stdin').option("--confirm", "confirm this bulk write").option("--idempotency-key <key>", "reuse across retries (default: a fresh UUID)").action(async (flags, command) => {
+    const ctx = resolveContext(command);
+    const { key } = resolveApiKey(command.optsWithGlobals().apiKey);
+    await runJobsBatch(ctx, key, flags.file, flags.confirm === true, flags.idempotencyKey ?? (0, import_node_crypto4.randomUUID)());
+  });
+}
+
 // src/commands/enterprise/jobs/index.ts
 function registerEnterpriseJobsCommand(parent) {
-  const jobs = parent.command("jobs").description("List and view your company job postings");
+  const jobs = parent.command("jobs").description("Manage your company job postings");
   registerEnterpriseJobsList(jobs);
   registerEnterpriseJobsView(jobs);
+  registerEnterpriseJobsCreate(jobs);
+  registerEnterpriseJobsUpdate(jobs);
+  registerEnterpriseJobsPublish(jobs);
+  registerEnterpriseJobsUnpublish(jobs);
+  registerEnterpriseJobsDelete(jobs);
+  registerEnterpriseJobsCopy(jobs);
+  registerEnterpriseJobsClose(jobs);
+  registerEnterpriseJobsBatch(jobs);
+}
+
+// src/commands/enterprise/keys/list.ts
+function formatDate3(value) {
+  return value ? String(value).slice(0, 10) : "";
+}
+function formatScopes(scopes) {
+  return Array.isArray(scopes) ? scopes.join(",") : "";
+}
+async function runKeysList(ctx, apiKey) {
+  const { body } = await enterpriseGet(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    "/keys"
+  );
+  const keys = unwrapDataArray(body);
+  if (ctx.format === "json") {
+    printJson(keys);
+    return;
+  }
+  printTable(
+    keys,
+    [
+      { header: "ENC_ID", value: (r) => (r.enc_id ?? "").slice(0, 14) },
+      { header: "NAME", value: (r) => r.name ?? "", maxWidth: 24 },
+      { header: "LAST4", value: (r) => r.key_last4 ?? "" },
+      { header: "SCOPES", value: (r) => formatScopes(r.scopes), maxWidth: 28 },
+      { header: "STATUS", value: (r) => r.status ?? "" },
+      { header: "EXPIRES", value: (r) => formatDate3(r.expires_at), maxWidth: 12 },
+      { header: "LAST_USED", value: (r) => formatDate3(r.last_used_at), maxWidth: 12 }
+    ],
+    ctx.color
+  );
+  const active = keys.filter((k) => k.status === "active").length;
+  process.stdout.write(dim(`${keys.length} key(s), ${active} active.`, ctx.color) + "\n");
+}
+function registerEnterpriseKeysList(parent) {
+  parent.command("list").description("List your company API keys (masked)").action(async (_flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runKeysList(ctx, key);
+  });
+}
+
+// src/commands/enterprise/keys/rotate.ts
+var ENTERPRISE_KEY_EXPIRY_DAYS = [30, 60, 90];
+function validateExpiryDays(raw) {
+  if (raw === void 0) return void 0;
+  if (!ENTERPRISE_KEY_EXPIRY_DAYS.includes(raw)) {
+    throw new CliError(
+      `Invalid --expiry-days ${raw}. Allowed: ${ENTERPRISE_KEY_EXPIRY_DAYS.join(", ")}`,
+      ExitCode.InvalidArgument
+    );
+  }
+  return raw;
+}
+async function runKeysRotate(ctx, apiKey, encId, flags) {
+  const trimmed = encId.trim();
+  if (!trimmed) throw new CliError("enc_id must not be empty", ExitCode.InvalidArgument);
+  const expiryDays = validateExpiryDays(flags.expiryDays);
+  const requestBody = {};
+  if (expiryDays !== void 0) requestBody.expiry_days = expiryDays;
+  const { body } = await enterprisePost(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/keys/${encodeURIComponent(trimmed)}/rotate`,
+    requestBody
+  );
+  const issued = unwrapDataResponse(body);
+  if (ctx.format === "json") {
+    printJson(issued);
+  } else {
+    const plaintext = issued.api_key ?? "";
+    const shown = flags.reveal ? plaintext : maskKey(plaintext);
+    const lines = [
+      `New API key: ${sanitizeForTerminal(shown)}`,
+      `enc_id:      ${sanitizeForTerminal(issued.enc_id ?? "")}`,
+      `scopes:      ${sanitizeForTerminal((issued.scopes ?? []).join(","))}`,
+      `expires_at:  ${sanitizeForTerminal(issued.expires_at ?? "")}`
+    ];
+    process.stdout.write(lines.join("\n") + "\n");
+    if (!flags.reveal) {
+      process.stdout.write(dim("Re-run with --reveal to print the full key once.", ctx.color) + "\n");
+    }
+  }
+  printWarn(
+    `The previous key is now invalid. Update your ${API_KEY_ENV_VAR} env var / credential store, or run "wport enterprise login" with the new key.`,
+    ctx.color
+  );
+}
+function registerEnterpriseKeysRotate(parent) {
+  parent.command("rotate <enc_id>").description("Rotate an API key in place (issues a new key, invalidates the old one)").option("--expiry-days <n>", "new key lifetime in days (30 | 60 | 90; default 90)", (v) => Number(v)).option("--reveal", "print the full new key (default masks all but the last 4 chars)").action(async (encId, flags, command) => {
+    const ctx = resolveContext(command);
+    const globals = command.optsWithGlobals();
+    const { key } = resolveApiKey(globals.apiKey);
+    await runKeysRotate(ctx, key, encId, flags);
+  });
+}
+
+// src/commands/enterprise/keys/index.ts
+function registerEnterpriseKeysCommand(parent) {
+  const keys = parent.command("keys").description("List and rotate your company API keys");
+  registerEnterpriseKeysList(keys);
+  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 { body: respBody } = await enterprisePost(
+    { baseUrl: ctx.baseUrl, locale: ctx.locale, timeoutMs: ctx.timeoutMs, apiKey },
+    `/talents/${encodeURIComponent(trimmedId)}/respond`,
+    { subject, body },
+    { 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("--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 and respond to applicants in your talent pool");
+  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
@@ -1294,12 +2467,17 @@ function registerEnterpriseCommand(program2) {
   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.2.2", "-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.5.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);