@curviate/cli 0.1.0

package/dist/account-YOW2MCZS.js

@@ -0,0 +1,639 @@
+#!/usr/bin/env node
+import {
+  buildPreviewOutput
+} from "./chunk-R3VLWLVV.js";
+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/account.ts
+import { defineCommand } from "citty";
+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 buildOutputStreams() {
+  return {
+    stdout: { write: (s) => process.stdout.write(s) },
+    stderr: { write: (s) => process.stderr.write(s) }
+  };
+}
+function resolveOutputOpts(flags) {
+  return {
+    json: (flags.json ?? false) || !process.stdout.isTTY,
+    isTTY: process.stdout.isTTY ?? false,
+    fields: flags.fields
+  };
+}
+async function handleError(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 runAccountList(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  const outOpts = resolveOutputOpts(flags);
+  const all = flags.all ?? false;
+  const maxPages = flags["max-pages"] ? parseInt(flags["max-pages"], 10) : 100;
+  const limit = flags.limit ? parseInt(flags.limit, 10) : void 0;
+  const cursor = flags.cursor;
+  const params = {};
+  if (limit !== void 0) params["limit"] = limit;
+  if (cursor) params["cursor"] = cursor;
+  try {
+    if (all) {
+      const fn = (p) => client.accounts.list(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 client.accounts.list(params);
+      renderSuccess(result, outOpts, out);
+    }
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runAccountGet(client, flags, out) {
+  rejectPreviewOnRead(flags.preview, out);
+  rejectAllOnNonPaginated(flags.all, out);
+  const accountId = flags["account-id"] ?? "";
+  const outOpts = resolveOutputOpts(flags);
+  try {
+    const result = await client.accounts.get(accountId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+function buildAuthBody(flags) {
+  const body = {};
+  if (flags["auth-method"]) body["auth_method"] = flags["auth-method"];
+  if (flags["user-agent"]) body["user_agent"] = flags["user-agent"];
+  if (flags["recruiter-contract-id"]) body["recruiter_contract_id"] = flags["recruiter-contract-id"];
+  if (flags["auth-method"] === "credentials" && (flags.email || flags.password)) {
+    body["credentials"] = {
+      ...flags.email ? { email: flags.email } : {},
+      ...flags.password ? { password: flags.password } : {}
+    };
+  }
+  if (flags["auth-method"] === "cookie" && (flags["li-at"] || flags["li-a"])) {
+    body["cookie"] = {
+      ...flags["li-at"] ? { li_at: flags["li-at"] } : {},
+      ...flags["li-a"] ? { li_a: flags["li-a"] } : {}
+    };
+  }
+  if (flags.country) body["country"] = flags.country;
+  if (flags.ip) body["ip"] = flags.ip;
+  if (flags["proxy-host"]) {
+    body["proxy"] = {
+      protocol: flags["proxy-protocol"] ?? "http",
+      host: flags["proxy-host"],
+      port: flags["proxy-port"] ? parseInt(flags["proxy-port"], 10) : 80,
+      ...flags["proxy-username"] ? { username: flags["proxy-username"] } : {},
+      ...flags["proxy-password"] ? { password: flags["proxy-password"] } : {}
+    };
+  }
+  return body;
+}
+async function runAccountLink(client, flags, out) {
+  if (!flags["seat-id"]) {
+    out.stderr.write("error: --seat-id is required for account link.\n");
+    process.exit(2);
+  }
+  if (!flags["auth-method"]) {
+    out.stderr.write("error: --auth-method is required for account link (credentials | cookie).\n");
+    process.exit(2);
+  }
+  const body = {
+    seat_id: flags["seat-id"],
+    ...buildAuthBody(flags)
+  };
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({ method: "accounts.link", args: {}, body });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.accounts.link(body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runAccountConnectLink(client, flags, out) {
+  const body = {};
+  if (flags["seat-id"]) body["seat_id"] = flags["seat-id"];
+  if (flags["account-id"]) body["account_id"] = flags["account-id"];
+  if (flags.purpose) body["purpose"] = flags.purpose;
+  if (flags["expires-in-seconds"]) body["expires_in_seconds"] = parseInt(flags["expires-in-seconds"], 10);
+  if (flags["redirect-url"]) body["redirect_url"] = flags["redirect-url"];
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({ method: "accounts.createConnectLink", args: {}, body });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.accounts.createConnectLink(body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runAccountReconnect(client, flags, out) {
+  if (!flags["auth-method"]) {
+    out.stderr.write("error: --auth-method is required for account reconnect (credentials | cookie).\n");
+    process.exit(2);
+  }
+  const accountId = flags["account-id"] ?? "";
+  const body = buildAuthBody(flags);
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({
+      method: "accounts.reconnect",
+      args: { accountId },
+      body
+    });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.accounts.reconnect(accountId, body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runAccountRefresh(client, flags, out) {
+  const accountId = flags["account-id"] ?? "";
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({
+      method: "accounts.refresh",
+      args: { accountId },
+      body: {}
+    });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.accounts.refresh(accountId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runAccountUpdate(client, flags, out) {
+  const accountId = flags["account-id"] ?? "";
+  const body = {};
+  if (flags.country) body["country"] = flags.country;
+  if (flags.ip) body["ip"] = flags.ip;
+  if (flags["proxy-host"]) {
+    body["proxy"] = {
+      protocol: flags["proxy-protocol"] ?? "http",
+      host: flags["proxy-host"],
+      port: flags["proxy-port"] ? parseInt(flags["proxy-port"], 10) : 80,
+      ...flags["proxy-username"] ? { username: flags["proxy-username"] } : {},
+      ...flags["proxy-password"] ? { password: flags["proxy-password"] } : {}
+    };
+  }
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({
+      method: "accounts.update",
+      args: { accountId },
+      body
+    });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.accounts.update(accountId, body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runAccountDisconnect(client, flags, out) {
+  const accountId = flags["account-id"] ?? "";
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({
+      method: "accounts.disconnect",
+      args: { accountId },
+      body: {}
+    });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.accounts.disconnect(accountId);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runAccountCheckpointSubmit(client, flags, out) {
+  if (!flags.checkpoint) {
+    out.stderr.write("error: --checkpoint is required (the provisional account_id from the 202 response).\n");
+    process.exit(2);
+  }
+  if (!flags.code) {
+    out.stderr.write("error: --code is required (the OTP / 2FA code).\n");
+    process.exit(2);
+  }
+  const body = {
+    account_id: flags.checkpoint,
+    code: flags.code
+  };
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({
+      method: "accounts.submitCheckpoint",
+      args: {},
+      body
+    });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.accounts.submitCheckpoint(body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+async function runAccountCheckpointPoll(client, flags, out) {
+  if (!flags.checkpoint) {
+    out.stderr.write("error: --checkpoint is required (the provisional account_id from the 202 response).\n");
+    process.exit(2);
+  }
+  const body = {
+    account_id: flags.checkpoint
+  };
+  const outOpts = resolveOutputOpts(flags);
+  if (flags.preview) {
+    const preview = buildPreviewOutput({
+      method: "accounts.pollCheckpoint",
+      args: {},
+      body
+    });
+    out.stdout.write(JSON.stringify(preview) + "\n");
+    return;
+  }
+  try {
+    const result = await client.accounts.pollCheckpoint(body);
+    renderSuccess(result, outOpts, out);
+  } catch (err) {
+    await handleError(err, outOpts, out);
+  }
+}
+var accountListCommand = defineCommand({
+  meta: { name: "list", description: "List connected LinkedIn accounts." },
+  args: { ...GLOBAL_FLAGS },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountList(client, flags, out);
+  }
+});
+var accountGetCommand = defineCommand({
+  meta: { name: "get", description: "Get a connected LinkedIn account." },
+  args: {
+    ...GLOBAL_FLAGS,
+    "account-id": { type: "positional", description: "Account id (acc_\u2026)." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountGet(client, flags, out);
+  }
+});
+var accountLinkCommand = defineCommand({
+  meta: { name: "link", description: "Connect a LinkedIn account to an empty seat." },
+  args: {
+    ...GLOBAL_FLAGS,
+    "seat-id": { type: "string", description: "Empty seat to bind the account to.", required: true },
+    "auth-method": { type: "string", description: "Authentication method: credentials | cookie.", required: true },
+    email: { type: "string", description: "LinkedIn email (credentials method)." },
+    password: { type: "string", description: "LinkedIn password (credentials method)." },
+    "li-at": { type: "string", description: "LinkedIn session cookie li_at (cookie method)." },
+    "li-a": { type: "string", description: "Optional premium session cookie li_a (cookie method)." },
+    country: { type: "string", description: "Proxy location hint (ISO 3166-1 alpha-2)." },
+    ip: { type: "string", description: "IP to infer the managed proxy location." },
+    "proxy-protocol": { type: "string", description: "Proxy protocol: http | https | socks5." },
+    "proxy-host": { type: "string", description: "Proxy host or IP." },
+    "proxy-port": { type: "string", description: "Proxy port." },
+    "proxy-username": { type: "string", description: "Proxy auth username." },
+    "proxy-password": { type: "string", description: "Proxy auth password." },
+    "user-agent": { type: "string", description: "Browser User-Agent to pin for this account." },
+    "recruiter-contract-id": { type: "string", description: "Recruiter contract to bind to (Recruiter tier only)." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountLink(client, flags, out);
+  }
+});
+var accountConnectLinkCommand = defineCommand({
+  meta: { name: "connect-link", description: "Generate a one-time hosted account connection URL." },
+  args: {
+    ...GLOBAL_FLAGS,
+    "seat-id": { type: "string", description: "Target seat (required when purpose=create)." },
+    "account-id": { type: "string", description: "Account to reconnect (required when purpose=reconnect)." },
+    purpose: { type: "string", description: "create | reconnect (default: create)." },
+    "expires-in-seconds": { type: "string", description: "Link expiry in seconds (60\u20133600, default 900)." },
+    "redirect-url": { type: "string", description: "Browser return URL after the hosted flow." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountConnectLink(client, flags, out);
+  }
+});
+var accountReconnectCommand = defineCommand({
+  meta: { name: "reconnect", description: "Re-authorize a disconnected account in place." },
+  args: {
+    ...GLOBAL_FLAGS,
+    "account-id": { type: "positional", description: "Account id (acc_\u2026)." },
+    "auth-method": { type: "string", description: "Authentication method: credentials | cookie.", required: true },
+    email: { type: "string", description: "LinkedIn email (credentials method)." },
+    password: { type: "string", description: "LinkedIn password (credentials method)." },
+    "li-at": { type: "string", description: "LinkedIn session cookie li_at (cookie method)." },
+    "li-a": { type: "string", description: "Optional premium session cookie li_a (cookie method)." },
+    country: { type: "string", description: "Proxy location hint (ISO 3166-1 alpha-2)." },
+    ip: { type: "string", description: "IP to infer the managed proxy location." },
+    "proxy-protocol": { type: "string", description: "Proxy protocol: http | https | socks5." },
+    "proxy-host": { type: "string", description: "Proxy host or IP." },
+    "proxy-port": { type: "string", description: "Proxy port." },
+    "proxy-username": { type: "string", description: "Proxy auth username." },
+    "proxy-password": { type: "string", description: "Proxy auth password." },
+    "user-agent": { type: "string", description: "Browser User-Agent to pin." },
+    "recruiter-contract-id": { type: "string", description: "Recruiter contract id (Recruiter tier only)." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountReconnect(client, flags, out);
+  }
+});
+var accountRefreshCommand = defineCommand({
+  meta: { name: "refresh", description: "Refresh an account's synced data sources." },
+  args: {
+    ...GLOBAL_FLAGS,
+    "account-id": { type: "positional", description: "Account id (acc_\u2026)." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountRefresh(client, flags, out);
+  }
+});
+var accountUpdateCommand = defineCommand({
+  meta: { name: "update", description: "Update managed-proxy configuration for an account." },
+  args: {
+    ...GLOBAL_FLAGS,
+    "account-id": { type: "positional", description: "Account id (acc_\u2026)." },
+    country: { type: "string", description: "Proxy location hint (ISO 3166-1 alpha-2)." },
+    ip: { type: "string", description: "IP to infer the managed proxy location." },
+    "proxy-protocol": { type: "string", description: "Proxy protocol: http | https | socks5." },
+    "proxy-host": { type: "string", description: "Proxy host or IP." },
+    "proxy-port": { type: "string", description: "Proxy port." },
+    "proxy-username": { type: "string", description: "Proxy auth username." },
+    "proxy-password": { type: "string", description: "Proxy auth password." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountUpdate(client, flags, out);
+  }
+});
+var accountDisconnectCommand = defineCommand({
+  meta: { name: "disconnect", description: "Hard-disconnect a LinkedIn account and release its seat." },
+  args: {
+    ...GLOBAL_FLAGS,
+    "account-id": { type: "positional", description: "Account id (acc_\u2026)." }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountDisconnect(client, flags, out);
+  }
+});
+var accountCheckpointSubmitCommand = defineCommand({
+  meta: { name: "submit", description: "Submit an OTP / 2FA code to resolve a checkpoint challenge." },
+  args: {
+    ...GLOBAL_FLAGS,
+    checkpoint: {
+      type: "string",
+      description: "The provisional account_id from the 202 checkpoint_required response.",
+      required: true
+    },
+    code: {
+      type: "string",
+      description: "The OTP / 2FA verification code (or TRY_ANOTHER_WAY to switch challenge type).",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountCheckpointSubmit(client, flags, out);
+  }
+});
+var accountCheckpointPollCommand = defineCommand({
+  meta: { name: "poll", description: "Poll for mobile-app approval of a pending checkpoint challenge." },
+  args: {
+    ...GLOBAL_FLAGS,
+    checkpoint: {
+      type: "string",
+      description: "The provisional account_id from the 202 checkpoint_required response.",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const flags = args;
+    const cfg = await resolveEffectiveConfig({
+      apiKey: flags["api-key"],
+      baseUrl: flags["base-url"],
+      timeout: flags.timeout,
+      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 runAccountCheckpointPoll(client, flags, out);
+  }
+});
+var accountCheckpointCommand = defineCommand({
+  meta: { name: "checkpoint", description: "Checkpoint challenge operations (submit OTP or poll mobile-app approval)." },
+  subCommands: {
+    submit: accountCheckpointSubmitCommand,
+    poll: accountCheckpointPollCommand
+  },
+  async run() {
+    process.stderr.write("Usage: curviate account checkpoint submit | poll\n");
+  }
+});
+var accountCommand = defineCommand({
+  meta: { name: "account", description: "LinkedIn account connection management." },
+  subCommands: {
+    list: accountListCommand,
+    get: accountGetCommand,
+    link: accountLinkCommand,
+    "connect-link": accountConnectLinkCommand,
+    reconnect: accountReconnectCommand,
+    refresh: accountRefreshCommand,
+    update: accountUpdateCommand,
+    disconnect: accountDisconnectCommand,
+    checkpoint: accountCheckpointCommand
+  },
+  async run() {
+    process.stderr.write(
+      "Usage: curviate account <subcommand>\n  list | get | link | connect-link | reconnect | refresh | update | disconnect | checkpoint\n"
+    );
+  }
+});
+export {
+  accountCommand,
+  runAccountCheckpointPoll,
+  runAccountCheckpointSubmit,
+  runAccountConnectLink,
+  runAccountDisconnect,
+  runAccountGet,
+  runAccountLink,
+  runAccountList,
+  runAccountReconnect,
+  runAccountRefresh,
+  runAccountUpdate
+};