@meterapp/glossa 0.3.0 → 0.5.0

package/README.md

@@ -12,12 +12,13 @@ npx @meterapp/glossa fill translations.json                   # write [{"unit","
 npx @meterapp/glossa run_audit --locale es --question "Are brand names consistent?"
 npx @meterapp/glossa ops          # every op, live from the API
 npx @meterapp/glossa mcp          # stdio MCP bridge for hosts without HTTP MCP
-npx @meterapp/glossa pricing      # plans and prices, no key needed
-npx @meterapp/glossa billing      # this workspace's plan and usage
-npx @meterapp/glossa subscribe pro --interval year --open   # Stripe Checkout link for a human
+npx @meterapp/glossa pricing [--json]   # plans, prices and limits, no key needed
+npx @meterapp/glossa account            # plan, usage against every limit, next plan
+npx @meterapp/glossa upgrade --plan pro --yearly --open   # Stripe Checkout link for a human, even before login
+npx @meterapp/glossa billing portal     # invoices, card, plan change, cancel
 ```
 
-`subscribe` prints a Stripe Checkout link and charges nothing; a human pays in
+`upgrade` (alias `subscribe`) prints a Stripe Checkout link and charges nothing; a human pays in
 the browser. With `--confirm` it subscribes on the card already saved for the
 workspace instead, so pass it only after a human approved the plan and price.
 

package/bin/glossa.mjs

@@ -9,9 +9,11 @@ import { dirname, join, relative, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { brotliCompressSync, brotliDecompressSync, constants as zlib } from "node:zlib";
 
-const VERSION = "0.3.0";
+const VERSION = "0.5.0";
 const DEFAULT_HOST = "https://getglossa.dev";
 const CONFIG_PATH = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "glossa", "config.json");
+/** The last failed call, so `glossa feedback report --last` can attach it. */
+const LAST_ERROR_PATH = join(dirname(CONFIG_PATH), "last-error.json");
 const PROJECT_CONFIG = ".glossa.json";
 
 // ------------------------------------------------------------------ config
@@ -53,12 +55,13 @@ function fail(message, code = 1) {
 }
 
 // ------------------------------------------------------------------- http
-async function call(op, input = {}, { method = "POST" } = {}) {
+/** `anonymous: true` calls a public op without a key when none is saved (pricing, checkout before signup). */
+async function call(op, input = {}, { method = "POST", anonymous = false } = {}) {
   const key = apiKey();
-  if (!key) fail("not signed in. Run `glossa login` or set GLOSSA_API_KEY.");
+  if (!key && !anonymous) fail("not signed in. Run `glossa login` or set GLOSSA_API_KEY.");
   const response = await fetch(`${host()}/api/v1/${op}`, {
     method,
-    headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json", "X-Glossa-Integration": "cli", "User-Agent": `glossa-cli/${VERSION}` },
+    headers: { ...(key ? { Authorization: `Bearer ${key}` } : {}), "Content-Type": "application/json", "X-Glossa-Integration": "cli", "User-Agent": `glossa-cli/${VERSION}` },
     body: JSON.stringify(input),
   });
   const text = await response.text();
@@ -72,11 +75,24 @@ async function call(op, input = {}, { method = "POST" } = {}) {
     const error = new Error(body.detail || `${op} failed with HTTP ${response.status}`);
     error.status = response.status;
     error.body = body;
+    if (op !== "report_issue") rememberFailure(op, response.status, body, response.headers.get("x-request-id"));
     throw error;
   }
   return body;
 }
 
+/** Saves what `report --last` attaches: never the input, only the request id and the error. */
+function rememberFailure(op, status, body, headerId) {
+  try {
+    mkdirSync(dirname(LAST_ERROR_PATH), { recursive: true });
+    const record = { request_id: body.request_id ?? headerId ?? null, op, status, error_code: body.code ?? body.title ?? null, error: String(body.detail ?? "").slice(0, 2000), at: new Date().toISOString() };
+    writeFileSync(LAST_ERROR_PATH, JSON.stringify(record, null, 2) + "\n", { mode: 0o600 });
+  } catch {
+    // Best effort: a read-only home directory must not hide the real error.
+  }
+}
+const lastFailure = () => readJson(LAST_ERROR_PATH);
+
 async function manifest() {
   const response = await fetch(`${host()}/api/v1`, { headers: { "User-Agent": `glossa-cli/${VERSION}` } });
   if (!response.ok) fail(`could not read the op catalog from ${host()}/api/v1 (HTTP ${response.status}).`);
@@ -139,7 +155,7 @@ const money = (cents) => (cents === null || cents === undefined ? "custom" : `$$
 /** `subscribe <plan> [--interval year | --yearly] [--confirm]` as op input. */
 export function subscribeInput(positional, flags) {
   const plan = String(positional[0] ?? flags.plan ?? "").toLowerCase();
-  if (!["pro", "team"].includes(plan)) throw new Error('name a plan: `glossa subscribe pro` or `glossa subscribe team` (see `glossa pricing`).');
+  if (!["pro", "team"].includes(plan)) throw new Error('name a plan: `glossa upgrade --plan pro` or `--plan team` (see `glossa pricing`).');
   const interval = flags.yearly || flags.interval === "year" || flags.interval === "yearly" ? "year" : "month";
   return { plan, interval, ...(flags.confirm ? { confirm: true } : {}) };
 }
@@ -149,28 +165,56 @@ function openUrl(url) {
   spawn(command, [url], { stdio: "ignore", detached: true }).on("error", () => undefined).unref();
 }
 
+/** One line per plan from the shared pricing document (GET /api/v1/pricing). */
+export function pricingLines(doc) {
+  return doc.plans.map((plan) => {
+    const price = plan.price.monthly === null ? "custom" : plan.price.monthly === 0 ? "free" : `$${plan.price.monthly.toLocaleString("en-US")}/mo · $${plan.price.yearly.toLocaleString("en-US")}/yr`;
+    const included = plan.included.ai_translations_per_month === null ? "volume" : plan.included.ai_translations_per_month.toLocaleString("en-US");
+    const members = plan.limits.members === null ? "unlimited" : plan.limits.members;
+    const projects = plan.limits.projects === null ? "unlimited" : plan.limits.projects;
+    return { name: plan.name, text: `${price.padEnd(22)} ${included} AI translations/mo, ${members} members, ${projects} projects` };
+  });
+}
+
 async function pricing(flags) {
-  const response = await fetch(`${host()}/api/v1/get_pricing`, { headers: { "User-Agent": `glossa-cli/${VERSION}`, "X-Glossa-Integration": "cli" } });
+  const response = await fetch(`${host()}/api/v1/pricing`, { headers: { "User-Agent": `glossa-cli/${VERSION}`, "X-Glossa-Integration": "cli" } });
   if (!response.ok) fail(`could not read pricing (HTTP ${response.status}).`);
-  const catalog = await response.json();
-  if (flags.json || !isTTY) return print(catalog, flags);
-  for (const plan of catalog.plans) {
-    const price = plan.monthly_cents === null ? "custom" : plan.monthly_cents === 0 ? "free" : `${money(plan.monthly_cents)}/mo · ${money(plan.yearly_cents)}/yr`;
-    const allowance = plan.ai_translations_per_month === null ? "volume" : plan.ai_translations_per_month.toLocaleString("en-US");
-    console.log(`${bold(plan.name.padEnd(11))} ${price.padEnd(22)} ${allowance} AI translations/mo, ${plan.members} members`);
-  }
-  console.log(dim(`\n${catalog.unit}\nBuy: glossa subscribe pro [--interval year] [--open]`));
+  const doc = await response.json();
+  if (flags.json || !isTTY) return print(doc, flags);
+  for (const line of pricingLines(doc)) console.log(`${bold(line.name.padEnd(11))} ${line.text}`);
+  console.log(dim(`\n${doc.unit}\nBuy (no account needed first): glossa upgrade --plan pro [--yearly] [--open]`));
 }
 
-async function billing(flags) {
+const usageLine = (label, usage) => `  ${label.padEnd(16)} ${usage.used.toLocaleString("en-US")} of ${usage.included === null ? "unlimited" : usage.included.toLocaleString("en-US")}`;
+
+async function billing(positional, flags) {
+  if (positional[0] === "portal") {
+    const result = await call("get_billing_link");
+    if (flags.json || !isTTY) print(result, flags);
+    else console.log(`${result.message}\n${result.url}`);
+    if (flags.open) openUrl(result.url);
+    return;
+  }
   const state = await call("get_billing", flags.refresh ? { refresh: true } : {});
   if (flags.json || !isTTY) return print(state, flags);
   const when = state.ends_at ? `ends ${state.ends_at.slice(0, 10)}` : state.renews_at ? `renews ${state.renews_at.slice(0, 10)}` : "";
   console.log(`${bold(state.plan_name)} ${dim(state.status === "none" ? "" : state.status)} ${state.interval ? `${money(state.price_cents)}/${state.interval}` : ""} ${dim(when)}`.trim());
-  for (const [label, usage] of [["AI translations", state.usage.ai_translations], ["members", state.usage.members], ["projects", state.usage.projects]]) {
-    console.log(`  ${label.padEnd(16)} ${usage.used.toLocaleString("en-US")} of ${usage.included === null ? "unlimited" : usage.included.toLocaleString("en-US")}`);
+  for (const [label, usage] of [["AI translations", state.usage.ai_translations], ["members", state.usage.members], ["projects", state.usage.projects]]) console.log(usageLine(label, usage));
+  console.log(dim(`  card saved: ${state.payment_method_saved ? "yes" : "no"} · invoices and card: glossa billing portal`));
+}
+
+async function account(flags) {
+  const state = await call("get_account");
+  if (flags.json || !isTTY) return print(state, flags);
+  const when = state.ends_at ? `ends ${state.ends_at.slice(0, 10)}` : state.renews_at ? `renews ${state.renews_at.slice(0, 10)}` : "";
+  console.log(`${bold(state.workspace.name)} ${dim(`(${state.workspace.slug}, ${state.role})`)}`);
+  console.log(`${bold(state.plan_name)} ${state.interval ? `${money(state.price_cents)}/${state.interval}` : ""} ${dim(when)}`.trim());
+  for (const [label, usage] of [["AI translations", state.usage.ai_translations], ["members", state.usage.members], ["projects", state.usage.projects]]) console.log(usageLine(label, usage));
+  if (state.next_tier) {
+    const adds = state.next_tier.adds;
+    const more = adds.ai_translations_per_month ? `${adds.ai_translations_per_month.toLocaleString("en-US")} AI translations/mo` : adds.ai_translations_per_month === null ? "volume pricing" : "";
+    console.log(dim(`\nNext: ${state.next_tier.name}${state.next_tier.price.monthly ? ` ($${state.next_tier.price.monthly}/mo)` : ""}${more ? `, ${more}` : ""} → ${state.next_tier.checkout_url}`));
   }
-  console.log(dim(`  card saved: ${state.payment_method_saved ? "yes" : "no"} · ${state.manage_url}`));
 }
 
 /**
@@ -184,13 +228,17 @@ async function subscribe(positional, flags) {
   } catch (error) {
     fail(error.message);
   }
-  const result = input.confirm ? await call("subscribe", input) : await call("create_checkout_link", input);
+  if (input.confirm && !apiKey()) fail("--confirm charges a saved card and needs `glossa login` first. Without it you get a checkout link.");
+  const result = input.confirm ? await call("subscribe", input) : await call("create_checkout_link", input, { anonymous: true });
   const url = result.url ?? result.checkout_url ?? null;
+  // Paid before signing in: remember the session so `glossa login` attaches it to the workspace.
+  if (!apiKey() && result.session_id) saveUserConfig({ ...userConfig(), pending_checkout: result.session_id });
   if (flags.json || !isTTY) {
     print(result, flags);
   } else if (url) {
     console.log(`${bold(`${input.plan} · ${money(result.amount_cents)}/${input.interval}`)}: ${result.reason ?? "complete the purchase in Stripe Checkout (nothing is charged until you do)."}`);
     console.log(url);
+    if (!apiKey()) console.log(dim("After paying, run `glossa login`: the plan attaches to your workspace."));
   } else {
     console.log(green(`✓ ${result.status}: ${result.billing?.plan_name ?? input.plan} (${input.interval}ly)`));
   }
@@ -276,6 +324,26 @@ async function login(flags) {
   }
   const workspace = await call("get_workspace");
   console.log(green(`Signed in to ${workspace.name} (${workspace.slug}). Key saved to ${CONFIG_PATH}.`));
+  await claimPending();
+}
+
+/** Attaches a checkout paid before login (saved by `glossa upgrade`) to the workspace just signed in to. */
+async function claimPending() {
+  const config = userConfig();
+  if (!config.pending_checkout) return;
+  try {
+    const result = await call("claim_checkout", { session_id: config.pending_checkout });
+    console.log(green(`✓ ${result.billing.plan_name} is now this workspace's plan.`));
+    delete config.pending_checkout;
+    saveUserConfig(config);
+  } catch (error) {
+    if (error.body?.code === "checkout_incomplete") return console.log(dim("A checkout link is still open; finish paying, then run `glossa login` again (or `glossa claim_checkout --session-id …`)."));
+    if (["already_claimed", "not_found"].includes(error.body?.code)) {
+      delete config.pending_checkout;
+      saveUserConfig(config);
+    }
+    console.log(dim(`Could not attach the earlier checkout: ${error.message}`));
+  }
 }
 
 function logout() {
@@ -468,6 +536,173 @@ async function mcp() {
   });
 }
 
+// ---------------------------------------------------------------- feedback
+const FEEDBACK_USAGE = `glossa feedback list [--kind feature|issue] [--status active|all|done…] [--sort top|new|recent_activity] [--q text]
+glossa feedback show <id>
+glossa feedback mine
+glossa feedback request "<title>" [--body text] [--force]
+glossa feedback report "<title>" [--body text] [--request-id id] [--op op] [--project p --key k --locale l --file f] [--last] [--force]
+glossa feedback upvote <id> [--remove]
+glossa feedback comment <id> "<text>"
+glossa review --rating 1-5 [--title t] [--body b] [--likes l] [--dislikes d] [--use-case u] [--name n] [--company c] [--consent]
+glossa reviews [--sort newest|helpful|highest|lowest]`;
+
+const str = (value) => (value === undefined || value === true ? undefined : String(value));
+const compact = (object) => Object.fromEntries(Object.entries(object).filter(([, value]) => value !== undefined && value !== ""));
+
+/** `report` input: the title, body, flags as context, and with --last the last failed call. */
+export function reportInput(title, flags, last = null) {
+  if (!title) throw new Error('give the problem a title: glossa feedback report "push_file drops plural forms" --last');
+  if (flags.last && !last) throw new Error("no failed call recorded yet; pass --request-id from the error instead.");
+  const fromLast = flags.last && last ? compact({ request_id: last.request_id ?? undefined, op: last.op, status: last.status, error_code: last.error_code ?? undefined, error: last.error }) : {};
+  // Flags win over the recorded failure.
+  const context = {
+    ...fromLast,
+    ...compact({
+      request_id: str(flags["request-id"] ?? flags.request_id),
+      op: str(flags.op),
+      project: str(flags.project),
+      key: str(flags.key),
+      locale: str(flags.locale),
+      file: str(flags.file),
+      client: `glossa-cli/${VERSION}`,
+    }),
+  };
+  return compact({ title, details: str(flags.body ?? flags.details), context, force: flags.force ? true : undefined });
+}
+
+/** `review` flags as submit_review input. */
+export function reviewInput(flags) {
+  const rating = Number(flags.rating);
+  if (!Number.isInteger(rating) || rating < 1 || rating > 5) throw new Error("rate 1 to 5: glossa review --rating 5 --body \"…\"");
+  return compact({
+    rating,
+    title: str(flags.title),
+    body: str(flags.body),
+    likes: str(flags.likes),
+    dislikes: str(flags.dislikes),
+    use_case: str(flags["use-case"] ?? flags.use_case),
+    display_name: str(flags.name),
+    display_company: str(flags.company),
+    marketing_consent: flags.consent ? true : undefined,
+  });
+}
+
+/** `feedback <sub> …` as the op to call and its input. */
+export function feedbackCall(positional, flags, last = null) {
+  const [sub, ...rest] = positional;
+  const id = rest[0];
+  const needId = () => {
+    if (!/^\d+$/.test(String(id ?? ""))) throw new Error(`which item? glossa feedback ${sub} <id>`);
+    return Number(id);
+  };
+  switch (sub) {
+    case undefined:
+    case "list":
+      return { op: "list_feedback", anonymous: true, input: compact({ kind: str(flags.kind), status: str(flags.status), sort: str(flags.sort), q: str(flags.q), limit: flags.limit ? Number(flags.limit) : undefined, offset: flags.offset ? Number(flags.offset) : undefined }) };
+    case "show":
+      return { op: "get_feedback", anonymous: true, input: { id: needId() } };
+    case "mine":
+      return { op: "list_my_feedback", input: {} };
+    case "request":
+      if (!rest.join(" ").trim()) throw new Error('say what you want: glossa feedback request "Open a GitHub PR on pull"');
+      return { op: "request_feature", input: compact({ title: rest.join(" ").trim(), details: str(flags.body ?? flags.details), force: flags.force ? true : undefined }) };
+    case "report": {
+      // `report --last "title"` parses the title as --last's value.
+      const title = rest.join(" ").trim() || (typeof flags.last === "string" ? flags.last : "");
+      return { op: "report_issue", input: reportInput(title, flags, last) };
+    }
+    case "upvote":
+    case "vote":
+      return { op: flags.remove ? "remove_feedback_vote" : "upvote_feedback", input: { id: needId() } };
+    case "unvote":
+      return { op: "remove_feedback_vote", input: { id: needId() } };
+    case "comment": {
+      const body = rest.slice(1).join(" ").trim() || str(flags.body);
+      if (!body) throw new Error('what do you want to add? glossa feedback comment <id> "Same for us…"');
+      return { op: "comment_on_feedback", input: { id: needId(), body } };
+    }
+    default:
+      throw new Error(`unknown feedback command "${sub}".\n${FEEDBACK_USAGE}`);
+  }
+}
+
+function itemLine(item) {
+  const flags = [item.kind, item.status.replace(/_/g, " "), item.mine ? "yours" : null, item.voted ? "voted" : null].filter(Boolean).join(" · ");
+  return `${bold(String(item.votes).padStart(4))} ${dim(`#${item.id}`.padEnd(6))} ${item.title} ${dim(flags)}`;
+}
+
+async function feedback(positional, flags) {
+  let request;
+  try {
+    request = feedbackCall(positional, flags, lastFailure());
+  } catch (error) {
+    fail(error.message);
+  }
+  const result = await call(request.op, request.input, { anonymous: request.anonymous });
+  if (flags.json || !isTTY) return print(result, flags);
+  switch (request.op) {
+    case "list_feedback":
+      console.log(bold(`${result.total} items`));
+      for (const item of result.items) console.log(itemLine(item));
+      if (result.next_cursor) console.log(dim(`… more: --offset ${result.next_cursor}`));
+      return console.log(dim("\nUpvote: glossa feedback upvote <id> · new: glossa feedback request \"…\""));
+    case "get_feedback":
+      console.log(itemLine(result));
+      if (result.body) console.log(`\n${result.body}`);
+      for (const event of result.timeline.filter((e) => e.kind === "status")) console.log(dim(`  ${event.occurred_at.slice(0, 10)} ${event.from ?? ""} → ${event.to}${event.note ? `: ${event.note}` : ""}`));
+      for (const c of result.comment_list) console.log(`\n${c.official ? green(c.author) : bold(c.author)} ${dim(c.created_at.slice(0, 10))}\n${c.body}`);
+      return console.log(dim(`\n${result.url}`));
+    case "list_my_feedback":
+      console.log(bold(`Filed by your workspace (${result.items.length})`));
+      for (const item of result.items) console.log(itemLine(item));
+      console.log(bold(`\nFollowing (${result.subscriptions.length})`));
+      for (const item of result.subscriptions) console.log(`${itemLine(item)}${item.muted ? dim(" · muted") : ""}`);
+      if (result.review) console.log(bold(`\nYour review: ${"★".repeat(result.review.rating)}`) + dim(` ${result.review.status}`));
+      return console.log(dim(`\nFeedback email: ${result.email.subscribed ? "on" : "off"}${result.email.address ? ` (${result.email.address})` : ""}`));
+    case "request_feature":
+    case "report_issue":
+      if (!result.filed && !result.deduplicated) {
+        console.log(`${bold("Not filed:")} ${result.note}`);
+        for (const s of result.similar) console.log(`  ${dim(`#${s.id}`)} ${s.title} ${dim(`${s.votes} votes · ${s.status}`)}`);
+        return console.log(dim("\nglossa feedback upvote <id>, or add --force to file anyway."));
+      }
+      return console.log(`${green("✓")} ${result.note}\n${dim(result.url)}`);
+    default:
+      return console.log(`${green("✓")} ${result.note ?? itemLine(result.item ?? result)}`);
+  }
+}
+
+async function review(flags) {
+  if (flags.rating === undefined) {
+    const mine = await call("list_my_feedback");
+    if (flags.json || !isTTY) return print(mine.review, flags);
+    if (!mine.review) return console.log(`No review yet.\n${dim(FEEDBACK_USAGE.split("\n").slice(-2)[0])}`);
+    return console.log(`${"★".repeat(mine.review.rating)} ${bold(mine.review.title || "Your review")} ${dim(mine.review.status)}\n${mine.review.body}`);
+  }
+  let input;
+  try {
+    input = reviewInput(flags);
+  } catch (error) {
+    fail(error.message);
+  }
+  const result = await call("submit_review", input);
+  if (flags.json || !isTTY) return print(result, flags);
+  console.log(`${green("✓")} ${result.note}`);
+}
+
+async function reviews(flags) {
+  const result = await call("list_reviews", compact({ sort: str(flags.sort), rating: flags.rating ? Number(flags.rating) : undefined, limit: flags.limit ? Number(flags.limit) : undefined }), { anonymous: true });
+  if (flags.json || !isTTY) return print(result, flags);
+  const { average, count } = result.aggregate;
+  console.log(bold(`${average ?? "–"} / 5 from ${count} reviews`));
+  for (const r of result.reviews) {
+    console.log(`\n${"★".repeat(r.rating)}${"☆".repeat(5 - r.rating)} ${bold(r.title || "")} ${dim(`${r.author}${r.company ? `, ${r.company}` : ""} · ${r.created_at.slice(0, 10)}`)}`);
+    if (r.body) console.log(r.body);
+    if (r.response) console.log(dim(`  ↳ ${r.response.author}: ${r.response.body}`));
+  }
+}
+
 async function help() {
   console.log(`${bold("glossa")} ${VERSION} — localization your AI agents can run
 
@@ -484,11 +719,20 @@ ${bold("Usage")}
                                             [--status reviewed|needs_review] [--overwrite missing|machine|all]
   glossa tasks [--kind k] [--limit n]       the review queue
   glossa mcp                                stdio MCP bridge to the hosted server
-  glossa pricing                            plans and prices (no key needed)
+  glossa pricing [--json]                   plans, prices and limits (no key needed)
+  glossa account                            plan, usage against every limit, next plan
   glossa billing [--refresh]                this workspace's plan and usage
-  glossa subscribe pro|team [--interval year] [--open]
-                                            Stripe Checkout link for a human; --confirm
-                                            charges the saved card (only once approved)
+  glossa billing portal [--open]            invoices, card, plan change, cancel (Stripe)
+  glossa upgrade --plan pro|team [--yearly] [--open]
+                                            Stripe Checkout link for a human, also before
+                                            signing in (\`glossa login\` attaches it after);
+                                            --confirm charges the saved card (once approved)
+  glossa feedback list|show|mine|request|report|upvote|comment
+                                            feature requests and issue reports, upvotes,
+                                            comments; report --last attaches the last
+                                            failed call (glossa feedback --help)
+  glossa review --rating 1-5 [--body …]     post or edit your workspace's review
+  glossa reviews                            read reviews (no key needed)
   glossa <op> [--field value…] [--json '{…}' | @file | -]  run any op (glossa ops lists them)
   glossa ops                                list every op
 
@@ -530,10 +774,19 @@ async function main() {
     case "pricing":
       return pricing(flags);
     case "billing":
-      return billing(flags);
+      return billing(positional, flags);
+    case "account":
+      return account(flags);
     case "subscribe":
     case "upgrade":
       return subscribe(positional, flags);
+    case "feedback":
+      if (flags.help) return console.log(FEEDBACK_USAGE);
+      return feedback(positional, flags);
+    case "review":
+      return review(flags);
+    case "reviews":
+      return reviews(flags);
     case "ops": {
       const ops = await manifest();
       if (flags.json || !isTTY) return print(ops, flags);

package/bin/glossa.test.mjs

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { coerceFlags, deviceLogin, fileBody, fileText, parseArgs, readJsonArg, fillBatches, subscribeInput } from "./glossa.mjs";
+import { coerceFlags, deviceLogin, feedbackCall, fileBody, fileText, parseArgs, readJsonArg, fillBatches, pricingLines, reportInput, reviewInput, subscribeInput } from "./glossa.mjs";
+import { pricingDocument } from "../../../lib/billing/pricing";
 
 describe("cli args", () => {
   it("parses flags and positionals", () => {
@@ -100,3 +101,49 @@ describe("file bodies", () => {
     expect(fileText({ content: "x" })).toBe("x");
   });
 });
+
+describe("pricing", () => {
+  it("prints one line per plan from the shared pricing document", () => {
+    const lines = pricingLines(pricingDocument("agent-cli"));
+    expect(lines.map((l) => l.name)).toEqual(["Free", "Pro", "Team", "Enterprise"]);
+    expect(lines[1].text).toMatch(/^\$49\/mo · \$490\/yr .*25,000 AI translations\/mo, 10 members, unlimited projects$/);
+    expect(lines[3].text).toMatch(/^custom/);
+  });
+});
+
+describe("feedback", () => {
+  it("maps every feedback subcommand to its op", () => {
+    expect(feedbackCall([], {})).toEqual({ op: "list_feedback", anonymous: true, input: {} });
+    expect(feedbackCall(["list"], { kind: "issue", sort: "new", limit: "5" })).toEqual({ op: "list_feedback", anonymous: true, input: { kind: "issue", sort: "new", limit: 5 } });
+    expect(feedbackCall(["show", "42"], {})).toEqual({ op: "get_feedback", anonymous: true, input: { id: 42 } });
+    expect(feedbackCall(["mine"], {})).toEqual({ op: "list_my_feedback", input: {} });
+    expect(feedbackCall(["request", "Open", "a", "PR"], { body: "for CI", force: true })).toEqual({ op: "request_feature", input: { title: "Open a PR", details: "for CI", force: true } });
+    expect(feedbackCall(["upvote", "7"], {})).toEqual({ op: "upvote_feedback", input: { id: 7 } });
+    expect(feedbackCall(["upvote", "7"], { remove: true })).toEqual({ op: "remove_feedback_vote", input: { id: 7 } });
+    expect(feedbackCall(["comment", "7", "Same", "here"], {})).toEqual({ op: "comment_on_feedback", input: { id: 7, body: "Same here" } });
+  });
+
+  it("rejects missing ids, titles and unknown subcommands", () => {
+    expect(() => feedbackCall(["show"], {})).toThrow(/which item/);
+    expect(() => feedbackCall(["request"], {})).toThrow(/say what you want/);
+    expect(() => feedbackCall(["comment", "7"], {})).toThrow(/what do you want to add/);
+    expect(() => feedbackCall(["nope"], {})).toThrow(/unknown feedback command/);
+  });
+
+  it("report --last attaches the last failed call; flags add context", () => {
+    const last = { request_id: "req_9", op: "push_file", status: 500, error_code: "internal_error", error: "Something went wrong", at: "2026-10-17T00:00:00Z" };
+    const input = reportInput("push_file 500s", { last: true, project: "ios", locale: "de" }, last);
+    expect(input).toMatchObject({ title: "push_file 500s", context: { request_id: "req_9", op: "push_file", status: 500, error_code: "internal_error", error: "Something went wrong", project: "ios", locale: "de" } });
+    expect(input.context.client).toMatch(/^glossa-cli\//);
+    expect(reportInput("Docs typo", { "request-id": "req_1" }).context).toMatchObject({ request_id: "req_1" });
+    expect(() => reportInput("x y z", { last: true }, null)).toThrow(/no failed call/);
+    // `report --last "title"` parses the title as --last's value.
+    expect(feedbackCall(["report"], { last: "push_file 500s" }, last).input).toMatchObject({ title: "push_file 500s", context: { request_id: "req_9" } });
+  });
+
+  it("builds a review from flags", () => {
+    expect(reviewInput({ rating: "5", body: "Great", "use-case": "iOS app", consent: true, name: "Ann" })).toEqual({ rating: 5, body: "Great", use_case: "iOS app", display_name: "Ann", marketing_consent: true });
+    expect(() => reviewInput({ rating: "6" })).toThrow(/rate 1 to 5/);
+    expect(() => reviewInput({})).toThrow(/rate 1 to 5/);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meterapp/glossa",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Glossa CLI: push and pull translation files, run the AI review queue, and every other Glossa op from your terminal or CI. Includes a stdio MCP bridge.",
   "type": "module",
   "bin": { "glossa": "bin/glossa.mjs" },