@curviate/cli 0.1.0

package/dist/exit-codes-NFIR57ZA.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+// src/lib/exit-codes.ts
+var EXIT_CODE_MAP = {
+  // Auth (3)
+  UNAUTHORIZED: 3,
+  // Invalid input / usage (2)
+  INVALID_REQUEST: 2,
+  UNSUPPORTED_MEDIA_TYPE: 2,
+  PAYLOAD_TOO_LARGE: 2,
+  // Not found (4)
+  RESOURCE_NOT_FOUND: 4,
+  ACCOUNT_NOT_FOUND: 4,
+  SUBSCRIPTION_NOT_FOUND: 4,
+  SEAT_NOT_FOUND: 4,
+  // Tier / entitlement (5)
+  TIER_NOT_ACTIVE: 5,
+  LINKEDIN_FEATURE_NOT_SUBSCRIBED: 5,
+  // Rate-limited (6)
+  RATE_LIMIT_ACCOUNT: 6,
+  RATE_LIMIT_TENANT: 6,
+  PLATFORM_RATE_LIMIT: 6,
+  LINKEDIN_RATE_LIMITED: 6,
+  // Transient platform (7)
+  PLATFORM_ERROR: 7,
+  LINKEDIN_SERVICE_UNAVAILABLE: 7,
+  // Account / connection state (8)
+  ACCOUNT_RESTRICTED: 8,
+  LINKEDIN_AUTH_FAILED: 8,
+  LINKEDIN_COOKIE_INVALID: 8,
+  CONNECTION_IN_PROGRESS: 8,
+  // Checkpoint flow (9)
+  CHECKPOINT_NOT_FOUND: 9,
+  CHECKPOINT_EXPIRED: 9,
+  CHECKPOINT_INVALID_CODE: 9,
+  CHECKPOINT_MAX_ATTEMPTS: 9,
+  CHECKPOINT_ALREADY_RESOLVED: 9,
+  CHECKPOINT_UNSUPPORTED: 9,
+  // Messaging window / recipient (10)
+  MESSAGE_WINDOW_EXPIRED: 10,
+  RECIPIENT_UNREACHABLE: 10,
+  // Billing (11)
+  PAYMENT_REQUIRED: 11,
+  PAYMENT_FAILED: 11,
+  SUBSCRIPTION_BUSY: 11,
+  SEAT_CANCELLED: 11,
+  // Internal / uncaught (1) — last resort bucket
+  INTERNAL: 1,
+  PLATFORM_NOT_IMPLEMENTED: 1
+};
+function getExitCode(code) {
+  return EXIT_CODE_MAP[code] ?? 1;
+}
+export {
+  EXIT_CODE_MAP,
+  getExitCode
+};

package/dist/inbox-JBLYJMV2.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+import {
+  streamAll
+} from "./chunk-SND3NHCT.js";
+import {
+  createClient,
+  renderError,
+  renderSuccess,
+  renderUnexpectedError,
+  resolveEffectiveConfig
+} from "./chunk-2NCPJJPC.js";
+import {
+  GLOBAL_FLAGS
+} from "./chunk-6JNCLLNY.js";
+
+// src/commands/inbox.ts
+import { defineCommand } from "citty";
+function buildOutputStreams() {
+  return {
+    stdout: { write: (s) => process.stdout.write(s) },
+    stderr: { write: (s) => process.stderr.write(s) }
+  };
+}
+function requireAccount(account, out) {
+  if (!account) {
+    out.stderr.write("error: --account is required for this command. Set it via --account, CURVIATE_ACCOUNT, or `curviate config set-account`.\n");
+    process.exit(2);
+  }
+  return account;
+}
+function rejectPreviewOnRead(preview, out) {
+  if (preview) {
+    out.stderr.write("error: --preview is only valid on write commands (mutations). Reads just run.\n");
+    process.exit(2);
+  }
+}
+function rejectAllOnNonPaginated(all, out) {
+  if (all) {
+    out.stderr.write("error: --all is not supported on non-paginated commands.\n");
+    process.exit(2);
+  }
+}
+function resolveOutputOpts(flags) {
+  return {
+    json: (flags.json ?? false) || !process.stdout.isTTY,
+    isTTY: process.stdout.isTTY ?? false,
+    fields: flags.fields
+  };
+}
+function buildPaginationParams(flags) {
+  const params = {};
+  if (flags.limit !== void 0) params["limit"] = parseInt(flags.limit, 10);
+  if (flags.cursor) params["cursor"] = flags.cursor;
+  return params;
+}
+async function handleSdkError(err, outOpts, out) {
+  const { CurviateError } = await import("@curviate/sdk");
+  if (err instanceof CurviateError) {
+    const { getExitCode } = await import("./exit-codes-NFIR57ZA.js");
+    renderError(err, outOpts, out);
+    process.exit(getExitCode(err.code));
+  }
+  renderUnexpectedError(err, out);
+  process.exit(1);
+}
+async function runInboxList(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const all = flags.all ?? false;
+  const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+  const params = buildPaginationParams(flags);
+  try {
+    if (all) {
+      const fn = (p) => ns.messaging.listChats(p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        onTruncated: (msg) => out.stderr.write(msg + "\n")
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+    } else {
+      const result = await ns.messaging.listChats(params);
+      renderSuccess(result, outOpts, out);
+    }
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runInboxGet(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  rejectAllOnNonPaginated(flags.all, out);
+  const accountId = requireAccount(flags.account, out);
+  const chatId = flags.chatId ?? "";
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.messaging.getChat(chatId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runInboxMessages(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const accountId = requireAccount(flags.account, out);
+  const chatId = flags.chatId ?? "";
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  const all = flags.all ?? false;
+  const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+  const params = buildPaginationParams(flags);
+  try {
+    if (all) {
+      const fn = (p) => ns.messaging.listMessages(chatId, p);
+      for await (const item of streamAll(fn, params, {
+        maxPages,
+        onTruncated: (msg) => out.stderr.write(msg + "\n")
+      })) {
+        out.stdout.write(JSON.stringify(item) + "\n");
+      }
+    } else {
+      const result = await ns.messaging.listMessages(chatId, params);
+      renderSuccess(result, outOpts, out);
+    }
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runInboxSync(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  rejectAllOnNonPaginated(flags.all, out);
+  const accountId = requireAccount(flags.account, out);
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.messaging.syncMessages();
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+async function runInboxSyncChat(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  rejectAllOnNonPaginated(flags.all, out);
+  const accountId = requireAccount(flags.account, out);
+  const chatId = flags.chatId ?? "";
+  const ns = client.account(accountId);
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await ns.messaging.syncChat(chatId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleSdkError(err, outOpts, out);
+  }
+}
+var inboxListCommand = defineCommand({
+  meta: { name: "list", description: "List inbox chats." },
+  args: { ...GLOBAL_FLAGS },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runInboxList(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var inboxGetCommand = defineCommand({
+  meta: { name: "get", description: "Get details of a single chat." },
+  args: {
+    ...GLOBAL_FLAGS,
+    chatId: { type: "positional", description: "Chat ID." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runInboxGet(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var inboxMessagesCommand = defineCommand({
+  meta: { name: "messages", description: "List messages in a chat." },
+  args: {
+    ...GLOBAL_FLAGS,
+    chatId: { type: "positional", description: "Chat ID." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runInboxMessages(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var inboxSyncCommand = defineCommand({
+  meta: { name: "sync", description: "Re-sync account message history." },
+  args: { ...GLOBAL_FLAGS },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runInboxSync(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var inboxSyncChatCommand = defineCommand({
+  meta: { name: "sync-chat", description: "Re-sync a specific chat's message history." },
+  args: {
+    ...GLOBAL_FLAGS,
+    chatId: { type: "positional", description: "Chat ID." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      account: flags.account,
+      profile: flags.profile
+    });
+    if (!cfg.apiKey) {
+      process.stderr.write("error: no API key \u2014 run `curviate login` or pass --api-key.\n");
+      process.exit(3);
+    }
+    const client = createClient({ apiKey: cfg.apiKey, baseUrl: cfg.baseUrl, timeout: cfg.timeout });
+    const out = buildOutputStreams();
+    await runInboxSyncChat(client, { ...flags, account: flags.account ?? cfg.account }, out);
+  }
+});
+var inboxCommand = defineCommand({
+  meta: { name: "inbox", description: "Read and sync LinkedIn message inbox." },
+  subCommands: {
+    list: inboxListCommand,
+    get: inboxGetCommand,
+    messages: inboxMessagesCommand,
+    sync: inboxSyncCommand,
+    "sync-chat": inboxSyncChatCommand
+  },
+  async run() {
+    process.stderr.write(
+      "Usage: curviate inbox <subcommand>\n  list\n  get <chat_id>\n  messages <chat_id>\n  sync\n  sync-chat <chat_id>\n"
+    );
+  }
+});
+export {
+  inboxCommand,
+  runInboxGet,
+  runInboxList,
+  runInboxMessages,
+  runInboxSync,
+  runInboxSyncChat
+};

package/dist/login-VWJEBBFU.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import {
+  GLOBAL_FLAGS,
+  writeProfile
+} from "./chunk-6JNCLLNY.js";
+
+// src/commands/login.ts
+import { defineCommand } from "citty";
+
+// src/lib/readline.ts
+import { createInterface } from "readline";
+async function readlineSync(prompt, opts = {}) {
+  return new Promise((resolve, reject) => {
+    process.stderr.write(prompt);
+    if (opts.mask && typeof process.stdin.setRawMode === "function") {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding("utf8");
+      let input = "";
+      const onData = (char) => {
+        if (char === "\r" || char === "\n") {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener("data", onData);
+          process.stderr.write("\n");
+          resolve(input);
+        } else if (char === "") {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener("data", onData);
+          reject(new Error("Interrupted."));
+        } else if (char === "\x7F" || char === "\b") {
+          input = input.slice(0, -1);
+        } else {
+          input += char;
+        }
+      };
+      process.stdin.on("data", onData);
+    } else {
+      const rl = createInterface({
+        input: process.stdin,
+        output: void 0,
+        // suppress default echo (prompt already on stderr)
+        terminal: false
+      });
+      rl.once("line", (line) => {
+        rl.close();
+        resolve(line.trim());
+      });
+      rl.once("error", reject);
+      rl.once("close", () => resolve(""));
+    }
+  });
+}
+
+// src/commands/login.ts
+var loginCommand = defineCommand({
+  meta: {
+    name: "login",
+    description: "Save an API key to a local profile. Run `curviate profile me` to verify."
+  },
+  args: {
+    ...GLOBAL_FLAGS,
+    "api-key": {
+      type: "string",
+      description: 'API key to save. Pass "-" to read from stdin (keeps the key off argv).'
+    },
+    account: {
+      type: "string",
+      description: "Default account id to store with this profile."
+    },
+    profile: {
+      type: "string",
+      description: "Profile name to write to (default: default).",
+      default: "default"
+    }
+  },
+  async run({ args }) {
+    const profileName = args.profile ?? "default";
+    let apiKey = args["api-key"];
+    if (apiKey === "-") {
+      apiKey = await readStdin();
+    }
+    if (apiKey === void 0) {
+      if (process.stdin.isTTY) {
+        apiKey = await promptMasked("Enter your API key: ");
+      } else {
+        process.stderr.write(
+          "error: no API key \u2014 pass --api-key or run interactively on a TTY.\n"
+        );
+        process.exit(2);
+      }
+    }
+    apiKey = apiKey.trim();
+    if (!apiKey) {
+      process.stderr.write("error: API key must not be empty.\n");
+      process.exit(2);
+    }
+    const account = args.account ?? void 0;
+    await writeProfile(profileName, { apiKey, account });
+    process.stderr.write(
+      `Saved to profile "${profileName}". Run \`curviate profile me\` to verify.
+`
+    );
+  }
+});
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8").trim());
+    });
+    process.stdin.on("error", reject);
+  });
+}
+async function promptMasked(prompt) {
+  return readlineSync(prompt, { mask: true });
+}
+export {
+  loginCommand
+};