lagora-cli 1.1.0

package/dist/scripts/sdk.js

@@ -0,0 +1,256 @@
+// scripts/sdk-api-client.ts
+async function readSdkSnapshot(input) {
+  const flags = [
+    ...input.includeDiskUsage ? ["disk=1"] : [],
+    ...input.includePublished ? ["published=1"] : []
+  ];
+  const query = flags.length > 0 ? `?${flags.join("&")}` : "";
+  const payload = await requestJson(`${baseApiUrl(input.apiUrl)}/api/sdk${query}`, "GET", input.token);
+  return readSnapshot(payload);
+}
+async function readSdkPrepareLog(input) {
+  const payload = await requestJson(`${baseApiUrl(input.apiUrl)}/api/sdk/log`, "GET", input.token);
+  const text2 = record(payload, "SDK log").text;
+  return typeof text2 === "string" ? text2 : "";
+}
+async function startSdkUpdate(input) {
+  const flags = [
+    ...input.force ? ["force=1"] : [],
+    ...input.packageVersion ? [`version=${encodeURIComponent(input.packageVersion)}`] : []
+  ];
+  const query = flags.length > 0 ? `?${flags.join("&")}` : "";
+  const response = await fetch(`${baseApiUrl(input.apiUrl)}/api/sdk/update${query}`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${input.token}` }
+  });
+  const body = await response.text();
+  if (!response.ok && response.status !== 409) {
+    throw new Error(`SDK update request failed: HTTP ${response.status} ${body.slice(0, 240)}`);
+  }
+  const payload = parseJson(body, "SDK update");
+  const parsed = record(payload, "SDK update");
+  return {
+    started: parsed.started === true,
+    reason: typeof parsed.reason === "string" ? parsed.reason : void 0
+  };
+}
+async function requestJson(endpoint, method, token) {
+  const response = await fetch(endpoint, {
+    method,
+    headers: { authorization: `Bearer ${token}` }
+  });
+  const body = await response.text();
+  if (!response.ok) throw new Error(`SDK API request failed: HTTP ${response.status} ${body.slice(0, 240)}`);
+  return parseJson(body, "SDK API");
+}
+function parseJson(body, label) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw new Error(`${label} response was not JSON: ${body.slice(0, 240)}`);
+  }
+}
+function readSnapshot(payload) {
+  const parsed = record(payload, "SDK status");
+  const prepare = record(parsed.prepare, "SDK status prepare");
+  const versions = Array.isArray(parsed.versions) ? parsed.versions : [];
+  return {
+    prepare: {
+      status: text(prepare.status) ?? "unknown",
+      percent: typeof prepare.percent === "number" ? prepare.percent : 0,
+      currentStep: text(prepare.currentStep) ?? "",
+      repoUrl: text(prepare.repoUrl) ?? "",
+      branch: text(prepare.branch) ?? "",
+      preparedRoot: text(prepare.preparedRoot) ?? "",
+      commitSha: text(prepare.commitSha),
+      runId: text(prepare.runId),
+      startedAt: text(prepare.startedAt),
+      completedAt: text(prepare.completedAt),
+      message: text(prepare.message),
+      result: readResult(prepare.result),
+      events: readEvents(prepare.events)
+    },
+    versions: versions.map(readVersion),
+    publishedVersions: Array.isArray(parsed.publishedVersions) ? parsed.publishedVersions.filter((item) => typeof item === "string") : []
+  };
+}
+function readResult(value) {
+  if (!isRecord(value)) return void 0;
+  return {
+    status: text(value.status),
+    exitCode: typeof value.exitCode === "number" ? value.exitCode : void 0,
+    message: text(value.message)
+  };
+}
+function readEvents(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (!isRecord(item)) return [];
+    const at = text(item.at);
+    const step = text(item.step);
+    const message = text(item.message);
+    return at && step && message ? [{ at, step, message }] : [];
+  });
+}
+function readVersion(value) {
+  const parsed = record(value, "SDK version");
+  return {
+    name: text(parsed.name) ?? "",
+    status: text(parsed.status) ?? "unknown",
+    active: parsed.active === true,
+    branch: text(parsed.branch) ?? "",
+    commitSha: text(parsed.commitSha),
+    commitSubject: text(parsed.commitSubject),
+    completedAt: text(parsed.completedAt),
+    diskUsage: text(parsed.diskUsage),
+    packageVersion: text(parsed.packageVersion)
+  };
+}
+function record(value, label) {
+  if (!isRecord(value)) throw new Error(`${label} response has an unsupported shape`);
+  return value;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function baseApiUrl(apiUrl) {
+  return apiUrl.trim().replace(/\/+$/, "");
+}
+
+// scripts/sdk.ts
+var USAGE = "Usage: lagora sdk status|list|versions|log|update [--api-url url] [--token token] [--disk] [--force] [--watch] [--version published-version] [--interval seconds]";
+var DEFAULT_WATCH_INTERVAL_SECONDS = 30;
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["ready", "failed"]);
+function parseArgs(argv) {
+  const values = /* @__PURE__ */ new Map();
+  const flags = /* @__PURE__ */ new Set();
+  for (let index = 1; index < argv.length; index += 1) {
+    const option = argv[index];
+    if (!option?.startsWith("--")) continue;
+    if (option === "--force" || option === "--watch" || option === "--disk") {
+      flags.add(option);
+      continue;
+    }
+    const value = argv[index + 1];
+    if (!value || value.startsWith("--")) throw new Error(`${option} requires a value`);
+    values.set(option, value);
+    index += 1;
+  }
+  const interval = Number.parseInt(values.get("--interval") ?? "", 10);
+  return {
+    command: argv[0] ?? "status",
+    apiUrl: required(values.get("--api-url") ?? process.env.LAGORA_API_URL, "--api-url or LAGORA_API_URL"),
+    token: required(values.get("--token") ?? process.env.LAGORA_SDK_TOKEN, "--token or LAGORA_SDK_TOKEN"),
+    force: flags.has("--force"),
+    watch: flags.has("--watch"),
+    disk: flags.has("--disk"),
+    packageVersion: values.get("--version"),
+    intervalMs: (Number.isFinite(interval) && interval > 0 ? interval : DEFAULT_WATCH_INTERVAL_SECONDS) * 1e3
+  };
+}
+function required(value, name) {
+  if (!value?.trim()) throw new Error(`${name} is required`);
+  return value.trim();
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const endpoint = { apiUrl: args.apiUrl, token: args.token };
+  if (args.command === "status") {
+    printPrepare(await readSdkSnapshot(endpoint));
+    if (args.watch) await watchPrepare(args);
+    return;
+  }
+  if (args.command === "list") {
+    printVersions(await readSdkSnapshot({ ...endpoint, includeDiskUsage: args.disk }));
+    return;
+  }
+  if (args.command === "versions") {
+    const snapshot = await readSdkSnapshot({ ...endpoint, includePublished: true });
+    if (snapshot.publishedVersions.length === 0) {
+      console.log("No published versions. The package index may be unreachable; 'lagora sdk log' shows which path a prepare took.");
+      return;
+    }
+    const prepared = new Set(snapshot.versions.filter((version) => version.status === "ready").map((version) => version.packageVersion));
+    for (const version of snapshot.publishedVersions) {
+      console.log(`${prepared.has(version) ? "*" : " "} ${version}`);
+    }
+    console.log("");
+    console.log("* is already prepared. Prepare another with 'lagora sdk update --version <version>'.");
+    return;
+  }
+  if (args.command === "log") {
+    const text2 = await readSdkPrepareLog(endpoint);
+    console.log(text2.trim() || "No prepare log yet.");
+    return;
+  }
+  if (args.command === "update") {
+    const started = await startSdkUpdate({ ...endpoint, force: args.force, packageVersion: args.packageVersion });
+    const what = args.packageVersion ? ` (${args.packageVersion})` : args.force ? " (forced rebuild)" : "";
+    console.log(started.started ? `SDK update started${what}. Follow it with 'lagora sdk status --watch'.` : `SDK update not started: ${started.reason ?? "unknown reason"}.`);
+    if (args.watch) await watchPrepare(args);
+    return;
+  }
+  throw new Error(USAGE);
+}
+async function watchPrepare(args) {
+  let lastLine = "";
+  for (; ; ) {
+    await sleep(args.intervalMs);
+    const snapshot = await readSdkSnapshot({ apiUrl: args.apiUrl, token: args.token });
+    const line = `${snapshot.prepare.status} ${snapshot.prepare.percent}% \xB7 ${snapshot.prepare.currentStep}`;
+    if (line !== lastLine) {
+      console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${line}`);
+      lastLine = line;
+    }
+    if (TERMINAL_STATUSES.has(snapshot.prepare.status)) {
+      printPrepare(snapshot);
+      if (snapshot.prepare.status === "failed") process.exitCode = 1;
+      return;
+    }
+  }
+}
+function printPrepare(snapshot) {
+  const prepare = snapshot.prepare;
+  console.log(`prepare: ${prepare.status} ${prepare.percent}%`);
+  console.log(`step:    ${prepare.currentStep || "-"}`);
+  console.log(`source:  ${prepare.branch}${prepare.commitSha ? ` ${prepare.commitSha.slice(0, 12)}` : ""} \xB7 ${prepare.repoUrl}`);
+  console.log(`root:    ${prepare.preparedRoot}`);
+  if (prepare.startedAt) console.log(`started: ${prepare.startedAt}${prepare.completedAt ? ` \xB7 completed ${prepare.completedAt}` : ""}`);
+  if (prepare.result?.status === "failed") {
+    console.log(`failure: ${prepare.result.message ?? "prepare failed"}${prepare.result.exitCode === void 0 ? "" : ` (exit ${prepare.result.exitCode})`}`);
+    console.log("Run 'lagora sdk log' for the full build output.");
+  }
+  const ready = snapshot.versions.filter((version) => version.status === "ready").length;
+  console.log(`versions: ${snapshot.versions.length} prepared, ${ready} ready`);
+}
+function printVersions(snapshot) {
+  if (snapshot.versions.length === 0) {
+    console.log("No prepared SDK runtimes.");
+    return;
+  }
+  for (const version of snapshot.versions) {
+    console.log(`${version.active ? "*" : " "} ${describeVersion(version)}`);
+  }
+}
+function describeVersion(version) {
+  const parts = [
+    version.name,
+    version.status,
+    version.packageVersion ?? version.branch,
+    version.commitSha?.slice(0, 12),
+    version.completedAt,
+    version.diskUsage,
+    version.commitSubject
+  ];
+  return parts.filter(Boolean).join("  ");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/dist/scripts/site-feedback-CAPE5MPX.js

@@ -0,0 +1,136 @@
+import {
+  getIssueStoreRoot,
+  safeJoin
+} from "./chunk-UHJXD4TG.js";
+
+// lib/server/site-feedback.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+var SITE_FEEDBACK_MESSAGE_MAX_LENGTH = 4e3;
+var FEEDBACK_FILE = "site-feedback.json";
+var DEFAULT_MAX_STORED = 500;
+var DEFAULT_RATE_LIMIT = 5;
+var DEFAULT_RATE_LIMIT_WINDOW_MS = 10 * 60 * 1e3;
+async function listSiteFeedback() {
+  const items = await readFeedbackFile();
+  return [...items].sort((left, right) => new Date(right.createdAt).getTime() - new Date(left.createdAt).getTime());
+}
+async function addSiteFeedback(input, options = {}) {
+  const message = input.message.trim();
+  if (!message) return { ok: false, rejection: { code: "message_required" } };
+  if (message.length > SITE_FEEDBACK_MESSAGE_MAX_LENGTH) {
+    return {
+      ok: false,
+      rejection: { code: "message_too_long", length: message.length, maxLength: SITE_FEEDBACK_MESSAGE_MAX_LENGTH }
+    };
+  }
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const accountId = input.accountId?.trim();
+  if (accountId) {
+    const rejection = await rateLimitRejection(accountId, now.getTime());
+    if (rejection) return { ok: false, rejection };
+  }
+  const feedback = {
+    id: randomUUID(),
+    message,
+    pagePath: normalizedPagePath(input.pagePath),
+    reporter: input.reporter?.trim() || "Anonymous",
+    status: "open",
+    createdAt: now.toISOString()
+  };
+  const items = await readFeedbackFile();
+  await writeFeedbackFile(applyRetention([feedback, ...items]));
+  return { ok: true, feedback };
+}
+async function rateLimitRejection(accountId, nowMs) {
+  const { consumeSiteFeedbackSubmission } = await import("./site-feedback-rate-limit-5BU2WSFE.js");
+  const limit = submissionLimit();
+  const windowMs = submissionWindowMs();
+  const decision = await consumeSiteFeedbackSubmission(accountId, { limit, windowMs }, nowMs);
+  if (decision.allowed) return void 0;
+  return {
+    code: "rate_limited",
+    limit,
+    windowSeconds: Math.ceil(windowMs / 1e3),
+    retryAfterSeconds: decision.retryAfterSeconds
+  };
+}
+function applyRetention(items, maxStored = maxStoredFeedback()) {
+  if (items.length <= maxStored) return items;
+  const evicted = new Set(
+    [...items].sort(byEvictionPriority).slice(0, items.length - maxStored).map((item) => item.id)
+  );
+  return items.filter((item) => !evicted.has(item.id));
+}
+function byEvictionPriority(left, right) {
+  if (left.status !== right.status) return left.status === "resolved" ? -1 : 1;
+  return createdAtMs(left) - createdAtMs(right);
+}
+function createdAtMs(item) {
+  const parsed = new Date(item.createdAt).getTime();
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function maxStoredFeedback() {
+  return readPositiveInt(process.env.AGORA_SITE_FEEDBACK_MAX_STORED, DEFAULT_MAX_STORED);
+}
+function submissionLimit() {
+  return readPositiveInt(process.env.AGORA_SITE_FEEDBACK_RATE_LIMIT, DEFAULT_RATE_LIMIT);
+}
+function submissionWindowMs() {
+  return readPositiveInt(process.env.AGORA_SITE_FEEDBACK_RATE_LIMIT_WINDOW_MS, DEFAULT_RATE_LIMIT_WINDOW_MS);
+}
+function readPositiveInt(value, fallback) {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+async function resolveSiteFeedback(id, actor) {
+  const items = await readFeedbackFile();
+  const target = items.find((item) => item.id === id);
+  if (!target) return void 0;
+  const resolved = {
+    ...target,
+    status: "resolved",
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resolvedBy: actor.trim() || "Language Developer"
+  };
+  await writeFeedbackFile(items.map((item) => item.id === id ? resolved : item));
+  return resolved;
+}
+async function readFeedbackFile() {
+  const filePath = feedbackPath();
+  try {
+    const parsed = JSON.parse(await readFile(filePath, "utf8"));
+    return Array.isArray(parsed) ? parsed.filter(isSiteFeedback) : [];
+  } catch (error) {
+    if (error instanceof Error && "code" in error && Reflect.get(error, "code") === "ENOENT") return [];
+    throw error;
+  }
+}
+async function writeFeedbackFile(items) {
+  const filePath = feedbackPath();
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(items, null, 2)}
+`);
+}
+function feedbackPath() {
+  return safeJoin(getIssueStoreRoot(), FEEDBACK_FILE);
+}
+function normalizedPagePath(value) {
+  const text = value?.trim() || "/";
+  if (!text.startsWith("/")) return "/";
+  return text.slice(0, 240);
+}
+function isSiteFeedback(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const status = Reflect.get(value, "status");
+  return typeof Reflect.get(value, "id") === "string" && typeof Reflect.get(value, "message") === "string" && typeof Reflect.get(value, "pagePath") === "string" && typeof Reflect.get(value, "reporter") === "string" && (status === "open" || status === "resolved") && typeof Reflect.get(value, "createdAt") === "string";
+}
+export {
+  SITE_FEEDBACK_MESSAGE_MAX_LENGTH,
+  addSiteFeedback,
+  applyRetention,
+  listSiteFeedback,
+  resolveSiteFeedback
+};

package/dist/scripts/site-feedback-rate-limit-5BU2WSFE.js

@@ -0,0 +1,86 @@
+import {
+  getIssueStoreRoot,
+  safeJoin
+} from "./chunk-UHJXD4TG.js";
+
+// lib/server/site-feedback-rate-limit.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+var RATE_LIMIT_FILE = "site-feedback-rate-limit.json";
+var DEFAULT_MAX_TRACKED_ACCOUNTS = 2e3;
+var rateLimitMutation = Promise.resolve();
+function evaluateSiteFeedbackSubmission(state, accountId, settings, nowMs) {
+  const pruned = pruneExpired(state, settings.windowMs, nowMs);
+  const recent = pruned[accountId] ?? [];
+  if (recent.length >= settings.limit) {
+    const oldest = recent[0] ?? nowMs;
+    const retryAfterMs = Math.max(1, oldest + settings.windowMs - nowMs);
+    return {
+      decision: { allowed: false, retryAfterSeconds: Math.ceil(retryAfterMs / 1e3) },
+      state: capTrackedAccounts(pruned, settings)
+    };
+  }
+  return {
+    decision: { allowed: true, remaining: settings.limit - recent.length - 1 },
+    state: capTrackedAccounts({ ...pruned, [accountId]: [...recent, nowMs] }, settings)
+  };
+}
+async function consumeSiteFeedbackSubmission(accountId, settings, nowMs) {
+  const operation = rateLimitMutation.then(async () => {
+    const evaluation = evaluateSiteFeedbackSubmission(await readRateLimitState(), accountId, settings, nowMs);
+    await writeRateLimitState(evaluation.state);
+    return evaluation.decision;
+  });
+  rateLimitMutation = operation.then(() => void 0, () => void 0);
+  return operation;
+}
+async function readRateLimitState() {
+  try {
+    return parseRateLimitState(JSON.parse(await readFile(rateLimitPath(), "utf8")));
+  } catch (error) {
+    if (error instanceof SyntaxError) return {};
+    if (error instanceof Error && "code" in error && Reflect.get(error, "code") === "ENOENT") return {};
+    throw error;
+  }
+}
+async function writeRateLimitState(state) {
+  const filePath = rateLimitPath();
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(state, null, 2)}
+`);
+}
+function pruneExpired(state, windowMs, nowMs) {
+  const cutoff = nowMs - windowMs;
+  const entries = Object.entries(state).map(([accountId, instants]) => [accountId, instants.filter((instant) => instant > cutoff).sort(ascending)]).filter(([, instants]) => instants.length > 0);
+  return Object.fromEntries(entries);
+}
+function capTrackedAccounts(state, settings) {
+  const max = settings.maxTrackedAccounts ?? DEFAULT_MAX_TRACKED_ACCOUNTS;
+  const entries = Object.entries(state);
+  if (entries.length <= max) return state;
+  const retained = [...entries].sort(([, left], [, right]) => lastInstant(right) - lastInstant(left)).slice(0, max);
+  return Object.fromEntries(retained);
+}
+function lastInstant(instants) {
+  return instants[instants.length - 1] ?? 0;
+}
+function ascending(left, right) {
+  return left - right;
+}
+function rateLimitPath() {
+  return safeJoin(getIssueStoreRoot(), RATE_LIMIT_FILE);
+}
+function parseRateLimitState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const entries = Object.entries(value).map(([accountId, instants]) => [accountId, readInstants(instants)]).filter(([, instants]) => instants.length > 0);
+  return Object.fromEntries(entries);
+}
+function readInstants(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "number" && Number.isFinite(entry)).sort(ascending);
+}
+export {
+  consumeSiteFeedbackSubmission,
+  evaluateSiteFeedbackSubmission,
+  readRateLimitState
+};

package/dist/scripts/site-feedback.js

@@ -0,0 +1,117 @@
+import {
+  LagoraCliConfigStore,
+  apiSession,
+  baseApiUrl,
+  readJsonFromApi,
+  writeJsonToApi
+} from "./chunk-AZ3EEBVD.js";
+import "./chunk-TJZVQYBL.js";
+
+// scripts/site-feedback.ts
+import path from "node:path";
+
+// scripts/site-feedback-api-client.ts
+async function listFeedbackFromApi(session) {
+  const payload = await readJsonFromApi(`${baseApiUrl(session.apiUrl)}/api/site-feedback`, session);
+  return readFeedbackList(payload);
+}
+async function resolveFeedbackFromApi(input) {
+  const payload = await writeJsonToApi(`${baseApiUrl(input.session.apiUrl)}/api/site-feedback`, "PATCH", {
+    id: input.id,
+    actor: input.actor
+  }, input.session);
+  return readFeedback(payload);
+}
+function readFeedbackList(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("Feedback response has an unsupported shape");
+  }
+  const feedback = Reflect.get(payload, "feedback");
+  if (!Array.isArray(feedback) || !feedback.every(isSiteFeedback)) {
+    throw new Error("Feedback response has an unsupported shape");
+  }
+  return feedback;
+}
+function readFeedback(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("Feedback response has an unsupported shape");
+  }
+  const feedback = Reflect.get(payload, "feedback");
+  if (!isSiteFeedback(feedback)) throw new Error("Feedback response has an unsupported shape");
+  return feedback;
+}
+function isSiteFeedback(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const status = Reflect.get(value, "status");
+  return typeof Reflect.get(value, "id") === "string" && typeof Reflect.get(value, "message") === "string" && typeof Reflect.get(value, "pagePath") === "string" && typeof Reflect.get(value, "reporter") === "string" && (status === "open" || status === "resolved") && typeof Reflect.get(value, "createdAt") === "string";
+}
+
+// scripts/site-feedback.ts
+function parseArgs(argv) {
+  const args = { command: argv[0] };
+  for (let index = 1; index < argv.length; index += 1) {
+    const token = argv[index];
+    const value = argv[index + 1];
+    if (!token.startsWith("--")) continue;
+    if (!value || value.startsWith("--")) throw new Error(`${token} requires a value`);
+    index += 1;
+    if (token === "--id") args.id = value;
+    if (token === "--api-url") args.apiUrl = value;
+    if (token === "--author") args.author = value;
+    if (token === "--status") args.status = value;
+    if (token === "--store") args.store = value;
+  }
+  return args;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.store?.trim()) process.env.AGORA_ISSUE_STORE = path.resolve(args.store.trim());
+  const command = args.command ?? "list";
+  const config = new LagoraCliConfigStore();
+  const session = args.store?.trim() ? void 0 : await remoteSession(config, args.apiUrl);
+  if (command === "list" || command === "fetch") {
+    const feedback = session ? await listFeedbackFromApi(session) : await localFeedback();
+    printFeedback(feedback.filter((item) => !args.status || item.status === args.status));
+    return;
+  }
+  if (command === "resolve") {
+    const id = requireArg(args.id, "--id");
+    const actor = await config.author(args.author);
+    const feedback = session ? await resolveFeedbackFromApi({ session, id, actor }) : await resolveLocalFeedback(id, actor);
+    if (!feedback) throw new Error(`Feedback not found: ${id}`);
+    console.log(`Feedback resolved: ${feedback.id}`);
+    return;
+  }
+  throw new Error("Usage: lagora feedback list|fetch|resolve [--api-url url] [--store path] [--id feedback-id] [--status open|resolved]");
+}
+async function remoteSession(config, explicitApiUrl) {
+  const stored = await config.apiSession(explicitApiUrl);
+  return stored ? apiSession(stored.apiUrl, { cookie: stored.cookie, token: stored.token }) : void 0;
+}
+async function localFeedback() {
+  const { listSiteFeedback } = await import("./site-feedback-CAPE5MPX.js");
+  return listSiteFeedback();
+}
+async function resolveLocalFeedback(id, actor) {
+  const { resolveSiteFeedback } = await import("./site-feedback-CAPE5MPX.js");
+  return resolveSiteFeedback(id, actor);
+}
+function printFeedback(feedback) {
+  if (feedback.length === 0) {
+    console.log("No site feedback.");
+    return;
+  }
+  for (const item of feedback) {
+    console.log(`${item.id} [${item.status}] ${item.pagePath} \xB7 ${item.reporter} \xB7 ${item.createdAt}`);
+    console.log(item.message);
+    console.log("");
+  }
+}
+function requireArg(value, name) {
+  if (!value?.trim()) throw new Error(`${name} is required`);
+  return value.trim();
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/dist/scripts/storage-234FBH54.js

@@ -0,0 +1,67 @@
+import {
+  addComment,
+  addIssueBlocker,
+  addIssueTags,
+  addKernelSuggestion,
+  addTagDefinition,
+  assignIssue,
+  clearIssueAssignee,
+  closeIssue,
+  createIssue,
+  deleteComment,
+  deleteIssue,
+  deleteTagDefinition,
+  deleteVerificationRuns,
+  getArtifactTextPath,
+  getIssue,
+  hasRunningVerificationRun,
+  isAutoLoweringEnabled,
+  listIssues,
+  listTagDefinitions,
+  readArtifactText,
+  readAutomationSettings,
+  recordVerificationResult,
+  removeIssueBlocker,
+  syncIssueBlocker,
+  unassignIssue,
+  updateComment,
+  updateIssueDescription,
+  updateIssueStatus,
+  updateKernelSuggestion,
+  updateVerificationRunResult,
+  writeAutomationSettings
+} from "./chunk-NBJMYAOA.js";
+import "./chunk-QJPQHKIO.js";
+export {
+  addComment,
+  addIssueBlocker,
+  addIssueTags,
+  addKernelSuggestion,
+  addTagDefinition,
+  assignIssue,
+  clearIssueAssignee,
+  closeIssue,
+  createIssue,
+  deleteComment,
+  deleteIssue,
+  deleteTagDefinition,
+  deleteVerificationRuns,
+  getArtifactTextPath,
+  getIssue,
+  hasRunningVerificationRun,
+  isAutoLoweringEnabled,
+  listIssues,
+  listTagDefinitions,
+  readArtifactText,
+  readAutomationSettings,
+  recordVerificationResult,
+  removeIssueBlocker,
+  syncIssueBlocker,
+  unassignIssue,
+  updateComment,
+  updateIssueDescription,
+  updateIssueStatus,
+  updateKernelSuggestion,
+  updateVerificationRunResult,
+  writeAutomationSettings
+};