@meterapp/glossa 0.4.0 → 0.6.0

package/README.md

@@ -39,3 +39,12 @@ open the printed URL on any device (`--no-browser` skips opening one). To save
 an existing key instead, run `login --key gls_…`.
 
 In CI set `GLOSSA_API_KEY` (a workspace key, `gls_…`).
+
+### Cancel a background job
+
+`glossa cancel <job-id>` cancels queued or running work. `glossa cancel_job --job <job-id>`
+is the equivalent registry op. Completed translations remain in place, and repeated
+cancellation is safe. An in-flight model request may finish; translation workers
+check cancellation before storing its results or beginning the next batch.
+Use `glossa get_job --job <job-id>` to inspect progress and final status, or
+`glossa list_jobs --status cancelled` to list cancelled jobs.

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.4.0";
+const VERSION = "0.6.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
@@ -73,11 +75,24 @@ async function call(op, input = {}, { method = "POST", anonymous = false } = {})
     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}).`);
@@ -480,6 +495,14 @@ async function fill(positional, flags) {
   if (totals.rejected.length) process.exitCode = 1;
 }
 
+export function cancelJobInput(positional, flags) {
+  const job = positional[0] ?? flags.job;
+  if (positional.length > 1 || typeof job !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(job)) {
+    throw new Error("Usage: glossa cancel <job-id> (or --job <job-id>)");
+  }
+  return { job };
+}
+
 async function tasks(flags) {
   const { tasks: list, total } = await call("list_tasks", coerceFlags(flags, { properties: { limit: { type: "integer" }, kind: { type: "string" }, status: { type: "string" } } }));
   if (flags.json || !isTTY) return print({ total, tasks: list }, flags);
@@ -521,6 +544,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
 
@@ -535,6 +725,7 @@ ${bold("Usage")}
                                             their keys and file paths, for an agent
   glossa fill <file.json|->                 write translations: [{"unit","locale","text"}]
                                             [--status reviewed|needs_review] [--overwrite missing|machine|all]
+  glossa cancel <job-id>                   cancel queued or running work; keeps completed translations
   glossa tasks [--kind k] [--limit n]       the review queue
   glossa mcp                                stdio MCP bridge to the hosted server
   glossa pricing [--json]                   plans, prices and limits (no key needed)
@@ -545,6 +736,12 @@ ${bold("Usage")}
                                             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
 
@@ -579,6 +776,8 @@ async function main() {
       return missing(flags);
     case "fill":
       return fill(positional, flags);
+    case "cancel":
+      return print(await call("cancel_job", cancelJobInput(positional, flags)), flags);
     case "tasks":
       return tasks(flags);
     case "mcp":
@@ -592,6 +791,13 @@ async function main() {
     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,5 @@
 import { describe, expect, it } from "vitest";
-import { coerceFlags, deviceLogin, fileBody, fileText, parseArgs, readJsonArg, fillBatches, pricingLines, subscribeInput } from "./glossa.mjs";
+import { cancelJobInput, coerceFlags, deviceLogin, feedbackCall, fileBody, fileText, parseArgs, readJsonArg, fillBatches, pricingLines, reportInput, reviewInput, subscribeInput } from "./glossa.mjs";
 import { pricingDocument } from "../../../lib/billing/pricing";
 
 describe("cli args", () => {
@@ -110,3 +110,52 @@ describe("pricing", () => {
     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/);
+  });
+});
+
+
+describe("cancel", () => {
+  const job = "bcae2e7c-cbc6-466b-8d97-c21ac165d099";
+  it("accepts one job id as a positional or flag", () => {
+    expect(cancelJobInput([job], {})).toEqual({ job });
+    expect(cancelJobInput([], { job })).toEqual({ job });
+  });
+  it("rejects missing, malformed or extra ids", () => {
+    for (const ids of [[], ["invalid"], [job, job]]) expect(() => cancelJobInput(ids, {})).toThrow(/Usage/);
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meterapp/glossa",
-  "version": "0.4.0",
+  "version": "0.6.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" },