@flaredlink/cli 0.0.0-stage → 0.1.0

package/dist/flared.js

@@ -0,0 +1,896 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+import QRCode from "qrcode";
+
+// ../contracts/src/analytics.ts
+var clickEventMaxAgeMs = 48 * 60 * 60 * 1000;
+var clickEventMaxSkewMs = 5 * 60 * 1000;
+function isCount(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isRows(value, key) {
+  return Array.isArray(value) && value.every((row) => typeof row === "object" && row !== null && typeof row[key] === "string" && isCount(row.clicks));
+}
+function isLinkAnalytics(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const analytics = value;
+  return typeof analytics.linkId === "string" && typeof analytics.from === "string" && typeof analytics.to === "string" && isCount(analytics.total) && isRows(analytics.days, "day") && isRows(analytics.countries, "value") && isRows(analytics.devices, "value") && isRows(analytics.referrers, "value") && typeof analytics.asOf === "string";
+}
+function isUsage(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const usage = value;
+  return typeof usage.month === "string" && isCount(usage.clicks) && isCount(usage.clickLimit) && typeof usage.asOf === "string";
+}
+
+// ../contracts/src/errors.ts
+var errorStatus = {
+  INVALID_INPUT: 422,
+  IDEMPOTENCY_KEY_REQUIRED: 422,
+  IDEMPOTENCY_KEY_REUSED: 409,
+  SLUG_TAKEN: 409,
+  DEFAULT_DOMAIN_UNAVAILABLE: 409,
+  DOMAIN_UNAVAILABLE: 422,
+  PLAN_LIMIT_REACHED: 403,
+  RATE_LIMITED: 429,
+  UNAUTHENTICATED: 401,
+  ORIGIN_REJECTED: 403,
+  INSUFFICIENT_SCOPE: 403,
+  REAUTH_REQUIRED: 403,
+  TOKEN_LIMIT_REACHED: 403,
+  NO_WORKSPACE: 403,
+  WORKSPACE_PENDING: 503,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  PAYLOAD_TOO_LARGE: 413,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  SERVICE_UNAVAILABLE: 503
+};
+function isErrorCode(value) {
+  return typeof value === "string" && Object.hasOwn(errorStatus, value);
+}
+
+// ../contracts/src/links.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLink(value) {
+  if (!isRecord(value))
+    return false;
+  return typeof value.id === "string" && typeof value.domainId === "string" && typeof value.hostname === "string" && typeof value.slug === "string" && typeof value.shortUrl === "string" && typeof value.destination === "string" && (value.title === null || typeof value.title === "string") && typeof value.enabled === "boolean" && typeof value.createdAt === "string" && typeof value.updatedAt === "string";
+}
+function isListedLink(value) {
+  if (!isRecord(value) || !isLink(value))
+    return false;
+  const clicks = value.clicksLast30Days;
+  return clicks === null || Number.isSafeInteger(clicks) && clicks >= 0;
+}
+function isLinkPage(value) {
+  return isRecord(value) && Array.isArray(value.links) && value.links.every(isListedLink) && (value.nextCursor === null || typeof value.nextCursor === "string");
+}
+
+// ../contracts/src/tokens.ts
+var tokenScopes = [
+  "links:read",
+  "links:write",
+  "analytics:read",
+  "domains:read",
+  "usage:read"
+];
+var scopePresets = {
+  full: [...tokenScopes],
+  read: tokenScopes.filter((scope) => scope !== "links:write")
+};
+var tokenPrefix = "flr_";
+function isTokenScope(value) {
+  return typeof value === "string" && tokenScopes.includes(value);
+}
+function nullableString(value) {
+  return value === null || typeof value === "string";
+}
+function isApiIdentity(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const identity = value;
+  if (!Array.isArray(identity.scopes) || !identity.scopes.every(isTokenScope))
+    return false;
+  if (identity.kind === "session")
+    return true;
+  if (identity.kind !== "token" || typeof identity.token !== "object" || identity.token === null)
+    return false;
+  const token = identity.token;
+  return typeof token.id === "string" && typeof token.name === "string" && typeof token.start === "string" && nullableString(token.expiresAt);
+}
+
+// ../client/src/client.ts
+var defaultApiUrl = "https://api.flared.page/v1";
+
+class FlaredApiError extends Error {
+  code;
+  status;
+  requestId;
+  retryAfterSeconds;
+  field;
+  constructor(code, message, status, requestId = null, retryAfterSeconds = null, field = null) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this.retryAfterSeconds = retryAfterSeconds;
+    this.field = field;
+    this.name = "FlaredApiError";
+  }
+}
+var maxRetryWaitSeconds = 30;
+function normalizeBaseUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Use an absolute API URL, such as https://api.flared.page/v1.");
+  }
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback))
+    throw new Error("Use an HTTPS API URL. Plain HTTP is allowed only for localhost.");
+  if (url.username || url.password || url.search || url.hash)
+    throw new Error("Use an API URL without credentials, query, or fragment.");
+  return url.href.replace(/\/+$/, "");
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function retryAfter(response) {
+  const header = response.headers.get("retry-after");
+  const seconds = header === null || header.trim() === "" ? NaN : Number(header);
+  return Number.isFinite(seconds) && seconds >= 0 ? Math.ceil(seconds) : null;
+}
+async function failure(response) {
+  const body = record(await response.json().catch(() => null));
+  const error = record(body?.error);
+  const code = isErrorCode(error?.code) ? error.code : null;
+  return new FlaredApiError(code ?? (response.status >= 500 ? "SERVICE_UNAVAILABLE" : "INVALID_RESPONSE"), typeof error?.message === "string" ? error.message : `The API answered ${response.status}.`, response.status, typeof error?.requestId === "string" ? error.requestId : null, retryAfter(response), typeof error?.field === "string" ? error.field : null);
+}
+function invalid(status) {
+  return new FlaredApiError("INVALID_RESPONSE", "The API sent an unexpected response.", status);
+}
+function createClient(options) {
+  const baseUrl = normalizeBaseUrl(options.baseUrl);
+  const send = options.fetch ?? fetch;
+  const retries = options.retries ?? 2;
+  const sleep = options.sleep ?? ((milliseconds) => new Promise((done) => setTimeout(done, milliseconds)));
+  async function request(method, path, init) {
+    const headers = new Headers(init.headers);
+    headers.set("authorization", `Bearer ${options.token}`);
+    headers.set("accept", "application/json");
+    if (options.userAgent)
+      headers.set("user-agent", options.userAgent);
+    if (init.body !== undefined)
+      headers.set("content-type", "application/json");
+    for (let attempt = 0;; attempt += 1) {
+      let response;
+      try {
+        response = await send(`${baseUrl}${path}`, {
+          method,
+          headers,
+          body: init.body === undefined ? undefined : JSON.stringify(init.body)
+        });
+      } catch {
+        if (init.retry && attempt < retries) {
+          await sleep(1000 * 2 ** attempt);
+          continue;
+        }
+        throw new FlaredApiError("NETWORK_ERROR", "Could not reach the Flared API.", null);
+      }
+      if (response.ok) {
+        const body = await response.json().catch(() => {
+          return;
+        });
+        if (body === undefined)
+          throw invalid(response.status);
+        return { status: response.status, headers: response.headers, body };
+      }
+      const error = await failure(response);
+      const transient = response.status === 429 || response.status === 503;
+      const wait = error.retryAfterSeconds ?? 2 ** attempt;
+      if (init.retry && transient && attempt < retries && wait <= maxRetryWaitSeconds) {
+        await sleep(wait * 1000);
+        continue;
+      }
+      throw error;
+    }
+  }
+  const id = (value) => encodeURIComponent(value);
+  async function linkFrom(promise) {
+    const { status, body } = await promise;
+    const link = record(body)?.link;
+    if (!isLink(link))
+      throw invalid(status);
+    return link;
+  }
+  return {
+    async me() {
+      const { status, body } = await request("GET", "/me", { retry: true });
+      if (!isApiIdentity(body))
+        throw invalid(status);
+      return body;
+    },
+    async createLink({ idempotencyKey, ...input }) {
+      const key = idempotencyKey ?? crypto.randomUUID();
+      const response = await request("POST", "/links", {
+        body: input,
+        headers: { "idempotency-key": key },
+        retry: true
+      });
+      const link = record(response.body)?.link;
+      if (!isLink(link))
+        throw invalid(response.status);
+      return { link, replayed: response.headers.get("idempotent-replayed") === "true" };
+    },
+    async listLinks(query = {}) {
+      const params = new URLSearchParams;
+      if (query.limit !== undefined)
+        params.set("limit", String(query.limit));
+      if (query.cursor)
+        params.set("cursor", query.cursor);
+      if (query.search)
+        params.set("q", query.search);
+      const suffix = params.size ? `?${params}` : "";
+      const { status, body } = await request("GET", `/links${suffix}`, { retry: true });
+      if (!isLinkPage(body))
+        throw invalid(status);
+      return body;
+    },
+    getLink(linkId) {
+      return linkFrom(request("GET", `/links/${id(linkId)}`, { retry: true }));
+    },
+    updateLink(linkId, change) {
+      return linkFrom(request("PATCH", `/links/${id(linkId)}`, { body: change, retry: false }));
+    },
+    async getAnalytics(linkId, range = {}) {
+      const params = new URLSearchParams;
+      if (range.from)
+        params.set("from", range.from);
+      if (range.to)
+        params.set("to", range.to);
+      const suffix = params.size ? `?${params}` : "";
+      const { status, body } = await request("GET", `/links/${id(linkId)}/analytics${suffix}`, {
+        retry: true
+      });
+      const analytics = record(body)?.analytics;
+      if (!isLinkAnalytics(analytics))
+        throw invalid(status);
+      return analytics;
+    },
+    async getUsage() {
+      const { status, body } = await request("GET", "/usage", { retry: true });
+      const usage = record(body)?.usage;
+      if (!isUsage(usage))
+        throw invalid(status);
+      return usage;
+    }
+  };
+}
+
+// src/config.ts
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// src/exit.ts
+var exitCodes = {
+  ok: 0,
+  failure: 1,
+  usage: 2,
+  unauthenticated: 3,
+  forbidden: 4,
+  notFound: 5,
+  rejected: 6,
+  planLimit: 7,
+  rateLimited: 8,
+  unavailable: 9
+};
+function exitCodeFor(code) {
+  switch (code) {
+    case "UNAUTHENTICATED":
+      return exitCodes.unauthenticated;
+    case "INSUFFICIENT_SCOPE":
+    case "NO_WORKSPACE":
+    case "ORIGIN_REJECTED":
+    case "REAUTH_REQUIRED":
+      return exitCodes.forbidden;
+    case "NOT_FOUND":
+      return exitCodes.notFound;
+    case "INVALID_INPUT":
+    case "SLUG_TAKEN":
+    case "IDEMPOTENCY_KEY_REUSED":
+    case "IDEMPOTENCY_KEY_REQUIRED":
+    case "DEFAULT_DOMAIN_UNAVAILABLE":
+    case "DOMAIN_UNAVAILABLE":
+      return exitCodes.rejected;
+    case "PLAN_LIMIT_REACHED":
+    case "TOKEN_LIMIT_REACHED":
+      return exitCodes.planLimit;
+    case "RATE_LIMITED":
+      return exitCodes.rateLimited;
+    case "SERVICE_UNAVAILABLE":
+    case "WORKSPACE_PENDING":
+    case "NETWORK_ERROR":
+      return exitCodes.unavailable;
+    default:
+      return exitCodes.failure;
+  }
+}
+
+class UsageError extends Error {
+}
+
+class CliError extends Error {
+  exitCode;
+  code;
+  constructor(message, exitCode, code = "CLI_ERROR") {
+    super(message);
+    this.exitCode = exitCode;
+    this.code = code;
+  }
+}
+
+// src/config.ts
+function configDir(env, platform = process.platform) {
+  if (env.FLARED_CONFIG_DIR)
+    return env.FLARED_CONFIG_DIR;
+  if (platform === "win32" && env.APPDATA)
+    return join(env.APPDATA, "flared");
+  return join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "flared");
+}
+async function readConfig(dir) {
+  let text;
+  try {
+    text = await readFile(join(dir, "config.json"), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return {};
+    throw new CliError(`Cannot read ${join(dir, "config.json")}.`, exitCodes.failure);
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    value = null;
+  }
+  if (typeof value !== "object" || value === null)
+    throw new CliError(`${join(dir, "config.json")} is not valid. Run flared login again.`, exitCodes.failure);
+  const { apiUrl, token } = value;
+  return {
+    ...typeof apiUrl === "string" ? { apiUrl } : {},
+    ...typeof token === "string" ? { token } : {}
+  };
+}
+async function writeConfig(dir, config) {
+  await mkdir(dir, { recursive: true, mode: 448 });
+  await chmod(dir, 448).catch(() => {
+    return;
+  });
+  const file = join(dir, "config.json");
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  await rename(temporary, file);
+  await chmod(file, 384).catch(() => {
+    return;
+  });
+}
+async function deleteConfig(dir) {
+  await rm(join(dir, "config.json"), { force: true });
+}
+function checkToken(token) {
+  const value = token.trim();
+  if (!value.startsWith(tokenPrefix) || value.length > 128 || /\s/.test(value))
+    throw new UsageError(`An API token starts with ${tokenPrefix}. Create one in Settings.`);
+  return value;
+}
+function resolveApiUrl(option, env, saved) {
+  const value = option ?? env.FLARED_API_URL ?? saved.apiUrl ?? defaultApiUrl;
+  try {
+    return normalizeBaseUrl(value);
+  } catch (error) {
+    throw new UsageError(error.message);
+  }
+}
+function resolveToken(env, saved) {
+  const token = env.FLARED_TOKEN || saved.token;
+  if (!token)
+    throw new CliError("Not signed in. Run flared login, or set FLARED_TOKEN.", exitCodes.unauthenticated, "UNAUTHENTICATED");
+  return token;
+}
+
+// src/output.ts
+function table(rows) {
+  const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => row[column].length)));
+  return rows.map((row) => row.map((cell, column) => column === row.length - 1 ? cell : cell.padEnd(widths[column])).join("  ")).join(`
+`);
+}
+function shorten(text, length) {
+  return text.length > length ? `${text.slice(0, length - 1)}…` : text;
+}
+function utc(iso) {
+  return `${iso.slice(0, 16).replace("T", " ")} UTC`;
+}
+function linkTable(links) {
+  if (links.length === 0)
+    return "No links.";
+  return table([
+    ["SHORT URL", "CLICKS 30D", "STATUS", "DESTINATION"],
+    ...links.map((link) => [
+      link.shortUrl,
+      link.clicksLast30Days === null ? "-" : String(link.clicksLast30Days),
+      link.enabled ? "enabled" : "disabled",
+      shorten(link.destination, 60)
+    ])
+  ]);
+}
+function linkDetails(link) {
+  return table([
+    ["Short URL", link.shortUrl],
+    ["Destination", link.destination],
+    ["Title", link.title ?? "-"],
+    ["Status", link.enabled ? "enabled" : "disabled"],
+    ["Created", utc(link.createdAt)],
+    ["Updated", utc(link.updatedAt)],
+    ["ID", link.id]
+  ]);
+}
+function top(rows) {
+  if (rows.length === 0)
+    return "-";
+  return [...rows].sort((a, b) => b.clicks - a.clicks).slice(0, 5).map((row) => `${row.value} ${row.clicks}`).join(", ");
+}
+function analyticsReport(link, analytics) {
+  const clicks = analytics.total === 1 ? "1 click" : `${analytics.total} clicks`;
+  const days = analytics.days.filter((day) => day.clicks > 0);
+  return [
+    `${link.shortUrl}: ${clicks} from ${analytics.from} to ${analytics.to}`,
+    "",
+    days.length ? table([["DAY", "CLICKS"], ...days.map((day) => [day.day, String(day.clicks)])]) : "No clicks in this range.",
+    "",
+    table([
+      ["Countries", top(analytics.countries)],
+      ["Referrers", top(analytics.referrers)],
+      ["Devices", top(analytics.devices)],
+      ["As of", utc(analytics.asOf)]
+    ])
+  ].join(`
+`);
+}
+function usageReport(usage) {
+  return `${usage.clicks} of ${usage.clickLimit} clicks recorded in ${usage.month} (as of ${utc(usage.asOf)}).`;
+}
+function identityReport(identity, apiUrl) {
+  const rows = identity.kind === "token" ? [
+    ["Token", `${identity.token.name} (${identity.token.start}…)`],
+    ["Expires", identity.token.expiresAt ? utc(identity.token.expiresAt) : "never"]
+  ] : [["Session", "browser session"]];
+  return table([...rows, ["Scopes", identity.scopes.join(", ")], ["API", apiUrl]]);
+}
+
+// src/version.ts
+var cliVersion = "0.1.0";
+
+// src/cli.ts
+var optionTypes = {
+  json: { type: "boolean" },
+  "api-url": { type: "string" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" },
+  "token-stdin": { type: "boolean" },
+  slug: { type: "string" },
+  title: { type: "string" },
+  "clear-title": { type: "boolean" },
+  destination: { type: "string" },
+  "idempotency-key": { type: "string" },
+  search: { type: "string" },
+  limit: { type: "string" },
+  cursor: { type: "string" },
+  all: { type: "boolean" },
+  format: { type: "string" },
+  out: { type: "string" },
+  from: { type: "string" },
+  to: { type: "string" }
+};
+var uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function resolveLink(client, reference) {
+  if (uuid.test(reference))
+    return reference;
+  const page = await client.listLinks({ search: reference, limit: 100 });
+  const matches = page.links.filter((link) => link.slug === reference);
+  if (matches.length === 1)
+    return matches[0].id;
+  if (matches.length === 0)
+    throw new CliError(`No link with the slug "${reference}".`, exitCodes.notFound, "NOT_FOUND");
+  throw new UsageError(`Several links use the slug "${reference}". Use the link ID.`);
+}
+function limitOf(value) {
+  if (value === undefined)
+    return;
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+    throw new UsageError("Use a --limit from 1 to 100.");
+  return limit;
+}
+var commands = {
+  login: {
+    usage: "flared login [--token-stdin] [--api-url URL]",
+    summary: "Save an API token after the API accepts it.",
+    options: ["token-stdin"],
+    args: 0,
+    async run({ options, io, json, print }) {
+      let token;
+      if (options["token-stdin"])
+        token = await io.readStdin();
+      else if (io.stdinIsTTY)
+        token = await io.readSecret("API token (from Settings): ");
+      else
+        throw new UsageError("Pass the token on standard input with --token-stdin.");
+      token = checkToken(token);
+      const dir = configDir(io.env);
+      const apiUrl = resolveApiUrl(options["api-url"], io.env, await readConfig(dir));
+      const identity = await createClient({
+        baseUrl: apiUrl,
+        token,
+        fetch: io.fetch,
+        userAgent: `flared-cli/${cliVersion}`
+      }).me();
+      await writeConfig(dir, { apiUrl, token });
+      if (io.env.FLARED_TOKEN && !json)
+        io.stderr("FLARED_TOKEN is set, so it still takes precedence over the saved token.");
+      print(`Signed in. The token is saved in ${dir}.
+
+${identityReport(identity, apiUrl)}`, {
+        apiUrl,
+        ...identity
+      });
+    }
+  },
+  logout: {
+    usage: "flared logout",
+    summary: "Delete the saved token. Revoke it in Settings to stop it working.",
+    options: [],
+    args: 0,
+    async run({ io, print }) {
+      const dir = configDir(io.env);
+      await deleteConfig(dir);
+      print("Removed the saved token. It keeps working until you revoke it in Settings.", {
+        ok: true
+      });
+    }
+  },
+  whoami: {
+    usage: "flared whoami [--api-url URL]",
+    summary: "Show the token in use, its scopes, and the API URL.",
+    options: [],
+    args: 0,
+    async run({ client, apiUrl, print }) {
+      const identity = await (await client()).me();
+      const url = await apiUrl();
+      print(identityReport(identity, url), { apiUrl: url, ...identity });
+    }
+  },
+  "link create": {
+    usage: "flared link create URL [--slug SLUG] [--title TITLE] [--idempotency-key KEY]",
+    summary: "Create a short link and print its URL.",
+    options: ["slug", "title", "idempotency-key"],
+    args: 1,
+    async run({ args, options, client, print }) {
+      const result = await (await client()).createLink({
+        destination: args[0],
+        ...options.slug ? { slug: options.slug } : {},
+        ...options.title ? { title: options.title } : {},
+        ...options["idempotency-key"] ? { idempotencyKey: options["idempotency-key"] } : {}
+      });
+      print(result.link.shortUrl, result);
+    }
+  },
+  "link list": {
+    usage: "flared link list [--search TEXT] [--limit N] [--cursor CURSOR] [--all]",
+    summary: "List links, newest first.",
+    options: ["search", "limit", "cursor", "all"],
+    args: 0,
+    async run({ options, client, print }) {
+      const api = await client();
+      const limit = limitOf(options.limit);
+      const query = { limit, search: options.search, cursor: options.cursor };
+      if (!options.all) {
+        const page = await api.listLinks(query);
+        const more = page.nextCursor ? `
+
+More links: --cursor ${page.nextCursor}` : "";
+        return print(linkTable(page.links) + more, page);
+      }
+      const links = [];
+      let cursor = options.cursor;
+      for (let page = 0;page < 100; page += 1) {
+        const result = await api.listLinks({ ...query, limit: limit ?? 100, cursor });
+        links.push(...result.links);
+        if (!result.nextCursor)
+          break;
+        cursor = result.nextCursor;
+      }
+      print(linkTable(links), { links });
+    }
+  },
+  "link get": {
+    usage: "flared link get ID_OR_SLUG",
+    summary: "Show one link.",
+    options: [],
+    args: 1,
+    async run({ args, client, print }) {
+      const api = await client();
+      const link = await api.getLink(await resolveLink(api, args[0]));
+      print(linkDetails(link), { link });
+    }
+  },
+  "link update": {
+    usage: "flared link update ID_OR_SLUG [--destination URL] [--title TITLE | --clear-title]",
+    summary: "Change the destination or the title.",
+    options: ["destination", "title", "clear-title"],
+    args: 1,
+    async run({ args, options, client, print }) {
+      if (options.title !== undefined && options["clear-title"])
+        throw new UsageError("Use --title or --clear-title, not both.");
+      const change = {
+        ...options.destination !== undefined ? { destination: options.destination } : {},
+        ...options.title !== undefined ? { title: options.title } : {},
+        ...options["clear-title"] ? { title: null } : {}
+      };
+      if (Object.keys(change).length === 0)
+        throw new UsageError("Give --destination, --title, or --clear-title.");
+      const api = await client();
+      const link = await api.updateLink(await resolveLink(api, args[0]), change);
+      print(linkDetails(link), { link });
+    }
+  },
+  "link disable": {
+    usage: "flared link disable ID_OR_SLUG",
+    summary: "Stop a link from redirecting. Its slug stays reserved.",
+    options: [],
+    args: 1,
+    async run({ args, client, print }) {
+      const api = await client();
+      const link = await api.updateLink(await resolveLink(api, args[0]), { enabled: false });
+      print(`Disabled ${link.shortUrl}.`, { link });
+    }
+  },
+  "link enable": {
+    usage: "flared link enable ID_OR_SLUG",
+    summary: "Make a disabled link redirect again.",
+    options: [],
+    args: 1,
+    async run({ args, client, print }) {
+      const api = await client();
+      const link = await api.updateLink(await resolveLink(api, args[0]), { enabled: true });
+      print(`Enabled ${link.shortUrl}.`, { link });
+    }
+  },
+  "link qr": {
+    usage: "flared link qr ID_OR_SLUG [--format svg|png] [--out FILE]",
+    summary: "Make a QR code for the short URL. SVG goes to standard output without --out.",
+    options: ["format", "out"],
+    args: 1,
+    async run({ args, options, io, json, client, print }) {
+      const format = options.format ?? "svg";
+      if (format !== "svg" && format !== "png")
+        throw new UsageError("Use --format svg or png.");
+      if (format === "png" && !options.out)
+        throw new UsageError("A PNG needs --out FILE.");
+      if (json && !options.out)
+        throw new UsageError("With --json, give --out FILE.");
+      const api = await client();
+      const link = await api.getLink(await resolveLink(api, args[0]));
+      const data = format === "svg" ? await QRCode.toString(link.shortUrl, { type: "svg", margin: 2 }) : new Uint8Array(await QRCode.toBuffer(link.shortUrl, { type: "png", width: 512 }));
+      if (!options.out)
+        return io.stdout(String(data).trimEnd());
+      await io.writeFile(options.out, data);
+      print(`Saved the QR code for ${link.shortUrl} to ${options.out}.`, {
+        shortUrl: link.shortUrl,
+        format,
+        file: options.out
+      });
+    }
+  },
+  analytics: {
+    usage: "flared analytics ID_OR_SLUG [--from YYYY-MM-DD] [--to YYYY-MM-DD]",
+    summary: "Show clicks by day, country, referrer, and device.",
+    options: ["from", "to"],
+    args: 1,
+    async run({ args, options, client, print }) {
+      const api = await client();
+      const link = await api.getLink(await resolveLink(api, args[0]));
+      const analytics = await api.getAnalytics(link.id, { from: options.from, to: options.to });
+      print(analyticsReport(link, analytics), { analytics });
+    }
+  },
+  usage: {
+    usage: "flared usage",
+    summary: "Show recorded clicks this month and the allowance.",
+    options: [],
+    args: 0,
+    async run({ client, print }) {
+      const usage = await (await client()).getUsage();
+      print(usageReport(usage), { usage });
+    }
+  }
+};
+var globalOptions = "Options for every command: --json, --api-url URL, --help.";
+function help() {
+  return [
+    `flared ${cliVersion}: create, edit, and measure Flared short links.`,
+    "",
+    ...Object.values(commands).map((command) => `  ${command.usage}
+      ${command.summary}`),
+    "",
+    globalOptions,
+    "Environment: FLARED_TOKEN (token), FLARED_API_URL (self-hosted API, such as https://links.example.com/v1).",
+    "Exit codes: 0 ok, 1 failure, 2 usage, 3 not signed in, 4 not allowed, 5 not found,",
+    "6 rejected input, 7 plan limit, 8 rate limited, 9 service unavailable.",
+    "Docs: https://flared.page/docs#cli"
+  ].join(`
+`);
+}
+function findCommand(positionals) {
+  const [first, second, ...rest] = positionals;
+  if (first === "link") {
+    const name = `link ${second ?? ""}`;
+    const command2 = commands[name];
+    if (!command2)
+      throw new UsageError(`Unknown link command "${second ?? ""}".`);
+    return { name, command: command2, args: rest };
+  }
+  const command = first === undefined ? undefined : commands[first];
+  if (!command || first === undefined)
+    throw new UsageError(`Unknown command "${first ?? ""}".`);
+  return { name: first, command, args: positionals.slice(1) };
+}
+function report(io, json, code, message, requestId) {
+  if (json)
+    io.stderr(JSON.stringify({ error: { code, message, requestId } }));
+  else
+    io.stderr(`Error: ${message}${requestId ? ` (request ${requestId})` : ""}`);
+}
+async function run(argv, io) {
+  let json = argv.includes("--json");
+  try {
+    const parsed = parseArgs({
+      args: argv,
+      options: optionTypes,
+      allowPositionals: true,
+      strict: true
+    });
+    const options = parsed.values;
+    json = options.json === true;
+    if (options.version) {
+      io.stdout(cliVersion);
+      return exitCodes.ok;
+    }
+    if (parsed.positionals.length === 0) {
+      if (options.help) {
+        io.stdout(help());
+        return exitCodes.ok;
+      }
+      io.stderr(help());
+      return exitCodes.usage;
+    }
+    const { command, args } = findCommand(parsed.positionals);
+    if (options.help) {
+      io.stdout(`${command.usage}
+${command.summary}
+${globalOptions}`);
+      return exitCodes.ok;
+    }
+    const allowed = new Set(["json", "api-url", "help", ...command.options]);
+    const extra = Object.keys(options).find((name) => !allowed.has(name));
+    if (extra)
+      throw new UsageError(`--${extra} does not apply here. Usage: ${command.usage}`);
+    if (args.length !== command.args)
+      throw new UsageError(`Usage: ${command.usage}`);
+    let saved;
+    const config = async () => saved ??= await readConfig(configDir(io.env));
+    const apiUrl = async () => resolveApiUrl(options["api-url"], io.env, await config());
+    await command.run({
+      args,
+      options,
+      io,
+      json,
+      apiUrl,
+      async client() {
+        return createClient({
+          baseUrl: await apiUrl(),
+          token: resolveToken(io.env, await config()),
+          fetch: io.fetch,
+          userAgent: `flared-cli/${cliVersion}`
+        });
+      },
+      print(human, data) {
+        io.stdout(json ? JSON.stringify(data, null, 2) : human);
+      }
+    });
+    return exitCodes.ok;
+  } catch (error) {
+    if (error instanceof FlaredApiError) {
+      report(io, json, error.code, error.message, error.requestId);
+      return exitCodeFor(error.code);
+    }
+    if (error instanceof UsageError || error instanceof TypeError && "code" in error && String(error.code).startsWith("ERR_PARSE_ARGS")) {
+      report(io, json, "USAGE", error.message, null);
+      if (!json)
+        io.stderr("Run flared --help for the commands.");
+      return exitCodes.usage;
+    }
+    if (error instanceof CliError) {
+      report(io, json, error.code, error.message, null);
+      return error.exitCode;
+    }
+    report(io, json, "CLI_ERROR", "Something went wrong. Try again.", null);
+    return exitCodes.failure;
+  }
+}
+
+// src/prompt.ts
+function promptSecret(question) {
+  const input = process.stdin;
+  return new Promise((resolve, reject) => {
+    let value = "";
+    process.stderr.write(question);
+    input.setRawMode(true);
+    input.resume();
+    input.setEncoding("utf8");
+    const done = (error) => {
+      input.setRawMode(false);
+      input.pause();
+      input.off("data", onData);
+      process.stderr.write(`
+`);
+      if (error)
+        reject(error);
+      else
+        resolve(value);
+    };
+    const onData = (chunk) => {
+      for (const character of chunk) {
+        if (character === "\r" || character === `
+`)
+          return done();
+        if (character === "\x03")
+          return done(new CliError("Cancelled.", exitCodes.usage, "CANCELLED"));
+        if (character === "" || character === "\b")
+          value = value.slice(0, -1);
+        else if (character >= " ")
+          value += character;
+      }
+    };
+    input.on("data", onData);
+  });
+}
+async function readAll(stream) {
+  let text = "";
+  for await (const chunk of stream)
+    text += chunk.toString();
+  return text;
+}
+
+// src/main.ts
+process.exitCode = await run(process.argv.slice(2), {
+  stdout: (text) => process.stdout.write(`${text}
+`),
+  stderr: (text) => process.stderr.write(`${text}
+`),
+  env: process.env,
+  stdinIsTTY: process.stdin.isTTY === true,
+  readSecret: promptSecret,
+  readStdin: () => readAll(process.stdin),
+  writeFile: (path, data) => writeFile2(path, data)
+});