@curviate/cli 0.1.0

package/dist/chunk-2NCPJJPC.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import {
+  readConfig
+} from "./chunk-6JNCLLNY.js";
+
+// src/lib/resolve.ts
+var DEFAULT_BASE_URL = "https://api.curviate.com";
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function resolveEffectiveConfig(flags) {
+  const cfg = await readConfig();
+  const profileName = flags.profile ?? (cfg?.active ?? "default");
+  const profile = cfg?.profiles[profileName];
+  const apiKey = flags.apiKey ?? process.env["CURVIATE_API_KEY"] ?? profile?.apiKey ?? void 0;
+  const baseUrl = flags.baseUrl ?? process.env["CURVIATE_BASE_URL"] ?? profile?.baseUrl ?? DEFAULT_BASE_URL;
+  const timeoutFlag = flags.timeout !== void 0 ? parseInt(flags.timeout, 10) : void 0;
+  const timeout = timeoutFlag ?? profile?.timeout ?? DEFAULT_TIMEOUT_MS;
+  const account = flags.account ?? process.env["CURVIATE_ACCOUNT"] ?? profile?.account ?? void 0;
+  return { apiKey, baseUrl, timeout, account };
+}
+
+// src/lib/client.ts
+import { Curviate } from "@curviate/sdk";
+function createClient(config) {
+  return new Curviate({
+    apiKey: config.apiKey.trim(),
+    ...config.baseUrl !== void 0 ? { baseUrl: config.baseUrl } : {},
+    ...config.timeout !== void 0 ? { timeout: config.timeout } : {}
+  });
+}
+
+// src/lib/output.ts
+function isJsonMode(opts) {
+  return opts.json || !opts.isTTY;
+}
+function projectFields(obj, fields) {
+  if (fields.length === 0) return obj;
+  const result = {};
+  for (const field of fields) {
+    const parts = field.split(".");
+    let value = obj;
+    for (const part of parts) {
+      if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        value = value[part];
+      } else {
+        value = void 0;
+        break;
+      }
+    }
+    if (value !== void 0) {
+      result[field] = value;
+    }
+  }
+  return result;
+}
+function applyProjection(data, fields) {
+  if (fields.length === 0) return data;
+  if (Array.isArray(data)) {
+    return data.map(
+      (item) => typeof item === "object" && item !== null ? projectFields(item, fields) : item
+    );
+  }
+  if (typeof data === "object" && data !== null) {
+    const obj = data;
+    if (Array.isArray(obj["items"])) {
+      return {
+        ...obj,
+        items: obj["items"].map(
+          (item) => typeof item === "object" && item !== null ? projectFields(item, fields) : item
+        )
+      };
+    }
+    return projectFields(obj, fields);
+  }
+  return data;
+}
+function renderSuccess(data, opts, out) {
+  const json = isJsonMode(opts);
+  const fields = opts.fields ? opts.fields.split(",").map((f) => f.trim()).filter(Boolean) : [];
+  const projected = applyProjection(data, fields);
+  if (json) {
+    out.stdout.write(JSON.stringify(projected) + "\n");
+  } else {
+    out.stdout.write(renderHuman(projected) + "\n");
+  }
+}
+function renderHuman(data) {
+  if (data === null || data === void 0) return "(empty)";
+  if (typeof data === "object" && !Array.isArray(data)) {
+    const obj = data;
+    if (Array.isArray(obj["items"])) {
+      const items = obj["items"];
+      if (items.length === 0) return "(no items)";
+      return items.map(renderHuman).join("\n");
+    }
+    return Object.entries(obj).map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : String(v)}`).join("\n");
+  }
+  if (Array.isArray(data)) {
+    return data.map(renderHuman).join("\n");
+  }
+  return String(data);
+}
+function renderError(err, opts, out) {
+  const json = isJsonMode(opts);
+  const errJson = err.toJSON();
+  if (json) {
+    out.stdout.write(JSON.stringify({ error: errJson }) + "\n");
+    out.stderr.write(
+      `error [${errJson.code}] ${errJson.message}
+`
+    );
+  } else {
+    let msg = `Error: [${errJson.code}] ${errJson.message}`;
+    if (errJson.requiredTier) {
+      msg += `
+Required tier: ${errJson.requiredTier}`;
+    }
+    if (errJson.retryAfterMs) {
+      msg += `
+Retry after: ${errJson.retryAfterMs}ms`;
+    }
+    if (errJson.retryHint && errJson.retryHint.kind !== "never") {
+      msg += `
+Hint: ${errJson.retryHint.kind}`;
+    }
+    out.stderr.write(msg + "\n");
+  }
+}
+function renderUnexpectedError(err, out) {
+  const message = err instanceof Error ? err.message : "An unexpected error occurred.";
+  out.stderr.write(`Internal error: ${message}
+`);
+}
+
+export {
+  resolveEffectiveConfig,
+  createClient,
+  renderSuccess,
+  renderError,
+  renderUnexpectedError
+};

package/dist/chunk-6JNCLLNY.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+// src/lib/config.ts
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  rename,
+  chmod,
+  unlink
+} from "fs/promises";
+import { join, dirname } from "path";
+import { homedir, tmpdir } from "os";
+import { randomBytes } from "crypto";
+function getConfigPath() {
+  const xdg = process.env["XDG_CONFIG_HOME"] ?? (process.env["APPDATA"] ?? join(homedir(), ".config"));
+  return join(xdg, "curviate", "config.json");
+}
+async function readConfig() {
+  const cfgPath = getConfigPath();
+  let raw;
+  try {
+    raw = await readFile(cfgPath, "utf8");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") return null;
+    throw err;
+  }
+  return JSON.parse(raw);
+}
+async function writeConfig(cfg) {
+  const cfgPath = getConfigPath();
+  const cfgDir = dirname(cfgPath);
+  await mkdir(cfgDir, { recursive: true, mode: 448 });
+  try {
+    await chmod(cfgDir, 448);
+  } catch {
+  }
+  const content = JSON.stringify(cfg, null, 2) + "\n";
+  const tmpPath = join(
+    tmpdir(),
+    `curviate-cfg-${randomBytes(6).toString("hex")}.tmp`
+  );
+  try {
+    await writeFile(tmpPath, content, { encoding: "utf8", mode: 384 });
+    try {
+      await chmod(tmpPath, 384);
+    } catch {
+    }
+    await rename(tmpPath, cfgPath);
+    try {
+      await chmod(cfgPath, 384);
+    } catch {
+    }
+  } catch (err) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function writeProfile(profileName, entry) {
+  const existing = await readConfig() ?? {
+    active: profileName,
+    profiles: {}
+  };
+  const current = existing.profiles[profileName] ?? {};
+  existing.profiles[profileName] = { ...current, ...entry };
+  if (!existing.active) {
+    existing.active = profileName;
+  }
+  await writeConfig(existing);
+}
+async function setActiveProfile(profileName) {
+  const cfg = await readConfig();
+  if (!cfg || !cfg.profiles[profileName]) {
+    throw new Error(`Profile "${profileName}" not found.`);
+  }
+  cfg.active = profileName;
+  await writeConfig(cfg);
+}
+async function renameProfile(oldName, newName) {
+  const cfg = await readConfig();
+  if (!cfg || !cfg.profiles[oldName]) {
+    throw new Error(`Profile "${oldName}" not found.`);
+  }
+  if (cfg.profiles[newName]) {
+    throw new Error(
+      `Profile "${newName}" already exists \u2014 remove it first or choose another name.`
+    );
+  }
+  cfg.profiles[newName] = cfg.profiles[oldName];
+  delete cfg.profiles[oldName];
+  if (cfg.active === oldName) {
+    cfg.active = newName;
+  }
+  await writeConfig(cfg);
+}
+async function removeProfile(profileName) {
+  const cfg = await readConfig();
+  if (!cfg) return;
+  delete cfg.profiles[profileName];
+  if (cfg.active === profileName) {
+    cfg.active = "default";
+  }
+  await writeConfig(cfg);
+}
+async function updateProfileField(profileName, field, value) {
+  const cfg = await readConfig();
+  if (!cfg || !cfg.profiles[profileName]) {
+    throw new Error(`Profile "${profileName}" not found.`);
+  }
+  const profile = cfg.profiles[profileName];
+  if (profile) {
+    if (field === "timeout") {
+      profile.timeout = typeof value === "number" ? value : value !== void 0 ? Number(value) : void 0;
+    } else if (field === "apiKey") {
+      profile.apiKey = value !== void 0 ? String(value) : void 0;
+    } else if (field === "account") {
+      profile.account = value !== void 0 ? String(value) : void 0;
+    } else if (field === "baseUrl") {
+      profile.baseUrl = value !== void 0 ? String(value) : void 0;
+    }
+  }
+  await writeConfig(cfg);
+}
+
+// src/lib/global-flags.ts
+var GLOBAL_FLAGS = {
+  // Auth / config
+  "api-key": {
+    type: "string",
+    description: "API key (overrides env and profile). Note: a key passed on the command line is visible to other processes via `ps` and is saved in shell history; prefer the CURVIATE_API_KEY env var or `curviate login`."
+  },
+  profile: {
+    type: "string",
+    description: "Named profile to use from the config file."
+  },
+  account: {
+    type: "string",
+    description: "Account id for account-scoped commands."
+  },
+  "base-url": {
+    type: "string",
+    description: "Override the API base URL."
+  },
+  timeout: {
+    type: "string",
+    description: "Request timeout in milliseconds."
+  },
+  // Output
+  json: {
+    type: "boolean",
+    description: "Emit JSON output (default when stdout is not a TTY).",
+    default: false
+  },
+  fields: {
+    type: "string",
+    description: "Comma-separated dot-path field projection (e.g. id,name)."
+  },
+  limit: {
+    type: "string",
+    description: "Maximum items per page."
+  },
+  cursor: {
+    type: "string",
+    description: "Pagination cursor (opaque token from a previous response)."
+  },
+  all: {
+    type: "boolean",
+    description: "Stream all pages as NDJSON.",
+    default: false
+  },
+  "max-pages": {
+    type: "string",
+    description: "Maximum number of pages to fetch when --all is used."
+  },
+  preview: {
+    type: "boolean",
+    description: "Render the request that would be sent without calling the API.",
+    default: false
+  }
+};
+
+export {
+  getConfigPath,
+  readConfig,
+  writeProfile,
+  setActiveProfile,
+  renameProfile,
+  removeProfile,
+  updateProfileField,
+  GLOBAL_FLAGS
+};

package/dist/chunk-BNUTM6KD.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+// src/lib/identifier.ts
+var MEMBER_URL_RE = /^https?:\/\/(?:[a-z0-9-]+\.)?linkedin\.com\/in\/([^/?#]+)/i;
+var COMPANY_URL_RE = /^https?:\/\/(?:[a-z0-9-]+\.)?linkedin\.com\/company\/([^/?#]+)/i;
+var MEMBER_PATH_RE = /^\/in\/([^/?#/]+)\/?$/;
+var COMPANY_PATH_RE = /^\/company\/([^/?#/]+)\/?$/;
+function resolveIdentifier(raw) {
+  const memberUrlMatch = MEMBER_URL_RE.exec(raw);
+  if (memberUrlMatch?.[1]) {
+    return stripTrailingSlash(memberUrlMatch[1]);
+  }
+  const companyUrlMatch = COMPANY_URL_RE.exec(raw);
+  if (companyUrlMatch?.[1]) {
+    return stripTrailingSlash(companyUrlMatch[1]);
+  }
+  const memberPathMatch = MEMBER_PATH_RE.exec(raw);
+  if (memberPathMatch?.[1]) {
+    return memberPathMatch[1];
+  }
+  const companyPathMatch = COMPANY_PATH_RE.exec(raw);
+  if (companyPathMatch?.[1]) {
+    return companyPathMatch[1];
+  }
+  return raw;
+}
+function stripTrailingSlash(s) {
+  return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+
+export {
+  resolveIdentifier
+};

package/dist/chunk-Q43HZUN3.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+// src/lib/attach.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+var AttachError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.exitCode = 2;
+    this.name = "AttachError";
+  }
+};
+async function readAttachment(filePath) {
+  try {
+    const buf = await readFile(filePath);
+    return buf;
+  } catch (err) {
+    const filename = basename(filePath);
+    const reason = err instanceof Error ? err.message : "unknown error";
+    throw new AttachError(
+      `Cannot read attachment "${filename}": ${reason}. Pass a valid file path.`
+    );
+  }
+}
+
+export {
+  AttachError,
+  readAttachment
+};

package/dist/chunk-R3VLWLVV.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+// src/lib/preview.ts
+function buildPreviewOutput(req) {
+  const result = {
+    method: req.method,
+    args: req.args,
+    body: req.body
+  };
+  if (req.account !== void 0) {
+    result.account = req.account;
+  }
+  if (req.attachments && req.attachments.length > 0) {
+    result.attachments = req.attachments.map(
+      (a) => `${a.name} (${a.buffer.byteLength} bytes)`
+    );
+  }
+  return result;
+}
+
+export {
+  buildPreviewOutput
+};

package/dist/chunk-SND3NHCT.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+// src/lib/paginate.ts
+var PaginateError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.exitCode = 2;
+    this.name = "PaginateError";
+  }
+};
+async function* streamAll(fn, params, opts = {}) {
+  const maxPages = opts.maxPages ?? 100;
+  let cursor = void 0;
+  let pageCount = 0;
+  let firstPage = true;
+  while (true) {
+    const pageParams = cursor !== void 0 && cursor !== null ? { ...params, cursor } : params;
+    const page = await fn(pageParams);
+    pageCount++;
+    const items = page.items ?? page.data;
+    if (firstPage && !Array.isArray(items)) {
+      throw new PaginateError(
+        "--all requires a paginated method (response must have `items` or `data` array). Remove --all for non-list commands."
+      );
+    }
+    firstPage = false;
+    if (Array.isArray(items)) {
+      for (const item of items) {
+        yield item;
+      }
+    }
+    cursor = page.cursor;
+    if (!cursor) break;
+    if (pageCount >= maxPages) {
+      const msg = `Streaming truncated at ${maxPages} page(s) \u2014 more results may exist. Increase --max-pages or use --cursor / --limit for manual paging.`;
+      if (opts.onTruncated) {
+        opts.onTruncated(msg);
+      }
+      break;
+    }
+  }
+}
+
+export {
+  streamAll
+};

package/dist/chunk-UWO2D4HW.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// src/lib/binary.ts
+import { writeFile } from "fs/promises";
+var BinaryOutputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.exitCode = 2;
+    this.name = "BinaryOutputError";
+  }
+};
+async function writeBinaryOutput(data, opts) {
+  const buf = data instanceof Buffer ? data : Buffer.from(new Uint8Array(data));
+  if (opts.outputPath) {
+    await writeFile(opts.outputPath, buf);
+    return;
+  }
+  if (opts.isTTY) {
+    throw new BinaryOutputError(
+      "Binary output: pass -o <file> to save it, or redirect stdout to a file/pipe."
+    );
+  }
+  await new Promise((resolve, reject) => {
+    opts.stdout.write(buf, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+
+export {
+  BinaryOutputError,
+  writeBinaryOutput
+};

package/dist/cli.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { defineCommand } from "citty";
+import { createRequire } from "module";
+
+// src/dispatch.ts
+import { runCommand } from "citty";
+async function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+function firstPositionalIndex(rawArgs) {
+  return rawArgs.findIndex((a) => !a.startsWith("-"));
+}
+async function nodeHasPositional(cmd) {
+  const argsDef = await resolveValue(cmd.args ?? {});
+  return Object.values(argsDef).some((def) => def?.type === "positional");
+}
+async function declaredArgNames(cmd) {
+  const names = /* @__PURE__ */ new Set();
+  const argsDef = await resolveValue(cmd.args ?? {});
+  for (const [name, def] of Object.entries(argsDef)) {
+    names.add(name);
+    const alias = def?.alias;
+    if (typeof alias === "string") names.add(alias);
+    else if (Array.isArray(alias)) for (const a of alias) names.add(a);
+  }
+  return names;
+}
+function findUnknownFlag(rawArgs, declared) {
+  let afterDoubleDash = false;
+  for (const arg of rawArgs) {
+    if (afterDoubleDash) continue;
+    if (arg === "--") {
+      afterDoubleDash = true;
+      continue;
+    }
+    if (!arg.startsWith("-")) continue;
+    let name = arg.replace(/^-+/, "");
+    const eq = name.indexOf("=");
+    if (eq !== -1) name = name.slice(0, eq);
+    if (name.startsWith("no-")) name = name.slice(3);
+    if (name === "") continue;
+    if (!declared.has(name)) return arg;
+  }
+  return null;
+}
+function hasEmptyFields(rawArgs) {
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === "--fields") {
+      const next = rawArgs[i + 1];
+      if (next === void 0 || next.startsWith("-")) return true;
+      if (next.trim() === "") return true;
+    } else if (arg?.startsWith("--fields=")) {
+      if (arg.slice("--fields=".length).trim() === "") return true;
+    }
+  }
+  return false;
+}
+function usageError(message) {
+  process.stderr.write(`error: ${message}
+`);
+  process.stderr.write("Run `curviate --help` for usage.\n");
+  process.exit(2);
+}
+async function resolveLeaf(cmd, rawArgs) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const idx = firstPositionalIndex(rawArgs);
+    const token = idx === -1 ? void 0 : rawArgs[idx];
+    const hasBarePositional = await nodeHasPositional(cmd);
+    if (token !== void 0 && subCommands[token]) {
+      const sub = await resolveValue(subCommands[token]);
+      return resolveLeaf(sub, rawArgs.slice(idx + 1));
+    }
+    if (token !== void 0 && hasBarePositional) {
+      return { leaf: cmd, leafArgs: rawArgs };
+    }
+    if (token !== void 0) {
+      usageError(`unknown command \`${token}\``);
+    }
+    return { leaf: cmd, leafArgs: rawArgs };
+  }
+  return { leaf: cmd, leafArgs: rawArgs };
+}
+async function dispatch(root, rawArgs) {
+  if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+    const { showUsage, runMain } = await import("citty");
+    void showUsage;
+    await runMain(root, { rawArgs });
+    return;
+  }
+  if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+    const meta = await resolveValue(root.meta ?? {});
+    if (meta.version) {
+      process.stdout.write(meta.version + "\n");
+    }
+    process.exit(0);
+  }
+  try {
+    const { leaf, leafArgs } = await resolveLeaf(root, rawArgs);
+    if (hasEmptyFields(leafArgs)) {
+      usageError("--fields must not be empty.");
+    }
+    const declared = await declaredArgNames(leaf);
+    const unknown = findUnknownFlag(leafArgs, declared);
+    if (unknown !== null) {
+      usageError(`unknown flag \`${unknown}\`.`);
+    }
+    const leafToRun = { ...leaf, subCommands: void 0 };
+    await runCommand(leafToRun, { rawArgs: leafArgs });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const code = err?.code;
+    process.stderr.write(`error: ${message}
+`);
+    process.exit(code === "EARG" ? 2 : 1);
+  }
+}
+
+// src/cli.ts
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var require2 = createRequire(import.meta.url);
+var pkg = require2(resolve(__dirname, "../package.json"));
+var main = defineCommand({
+  meta: {
+    name: "curviate",
+    version: pkg.version,
+    description: "Official command-line interface for the Curviate API."
+  },
+  // Subcommand registry — names and descriptions are static for help rendering;
+  // the handler implementation is loaded lazily on first invocation.
+  subCommands: {
+    login: () => import("./login-VWJEBBFU.js").then((m) => m.loginCommand),
+    config: () => import("./config-4JOXBFYX.js").then((m) => m.configCommand),
+    // ---------------------------------------------------------------------------
+    // Noun groups — lazy-loaded on first invocation.
+    // ---------------------------------------------------------------------------
+    profile: () => import("./profile-WXA3NC7D.js").then((m) => m.profileCommand),
+    company: () => import("./company-IKVDW7MX.js").then((m) => m.companyCommand),
+    connect: () => import("./connect-HLDHFBGX.js").then((m) => m.connectCommand),
+    search: () => import("./search-LHPTHPWH.js").then((m) => m.searchCommand),
+    inbox: () => import("./inbox-JBLYJMV2.js").then((m) => m.inboxCommand),
+    message: () => import("./message-IK7VGB63.js").then((m) => m.messageCommand),
+    post: () => import("./post-EAAGVR5D.js").then((m) => m.postCommand),
+    account: () => import("./account-YOW2MCZS.js").then((m) => m.accountCommand),
+    webhook: () => import("./webhook-QM5LGAUF.js").then((m) => m.webhookCommand),
+    "sales-nav": () => import("./sales-nav-XGFO5I6F.js").then((m) => m.salesNavCommand),
+    recruiter: () => import("./recruiter-TGCV36EH.js").then((m) => m.recruiterCommand)
+  },
+  async run() {
+    const { runMain } = await import("citty");
+    await runMain(main, { rawArgs: ["--help"] });
+  }
+});
+void dispatch(main, process.argv.slice(2));