lagora-cli 1.1.0

package/README.md

@@ -0,0 +1,138 @@
+# lagora-cli
+
+Lean npm distribution of the Legato Agora CLI. The npm package is `lagora-cli`
+(unscoped); the executable remains `lagora`. Nothing has been published, so
+installing from the public registry doesn't work yet. Until a release exists,
+install from the internal GitHub release tarball or run
+`./bin/lagora` from a repository checkout as described in the
+[root README](../../README.md#install-the-cli-package).
+
+After a public release:
+
+```sh
+npm install -g lagora-cli
+lagora login
+lagora help
+```
+
+`lagora login` opens the browser flow described in the root README and stores a
+CLI-scoped token; nothing about login changes in the npm build.
+
+Requires Node.js 22.16 or newer. Remote login, reports, issue commands,
+Playground upload/status, SDK administration and feedback use compiled Node.js,
+without Next.js, React, tsx, Bash, curl or Python runtime dependencies. Login
+opens the system browser and prints the URL for manual use if opening fails.
+Saved login targets and `LAGORA_CONFIG` / `XDG_CONFIG_HOME` remain supported.
+
+`lagora report --store` retains the existing portable shell writer and requires
+Bash, Python 3 and standard Unix utilities. It preserves duplicate merging,
+artifact collision handling and optional `--auto-lowering`. Local reads and
+mutations remain isolated from the working directory's other stores.
+`playground validate` requires Python 3. Real lowering/fSIM and SDK preparation
+also require the separately installed platform-specific SDK, Python and its
+build tools; this package does not install them or promise Windows portability
+for these optional paths. No live SDK build or production service is exercised
+by the package tests. Remote reports do not query GitHub CLI identity.
+
+## Self-update
+
+The installed CLI keeps itself current from the npm registry. Nothing runs in
+the background: no daemon, cron entry or extra dependency.
+
+### Automatic
+
+After an ordinary command finishes and prints its own output, the CLI checks
+for a newer stable release and installs it if found. The original command's
+exit code is preserved either way. Checks happen at most once every 24 hours
+per install prefix, and a failed or offline check counts toward that window, so
+a machine without network access sees at most one bounded attempt per day.
+Timeouts are short: the version lookup is capped at 4 seconds and the install
+at 45 seconds, with no retries.
+
+Turn it off in one of two ways:
+
+```sh
+lagora update --disable   # persisted; lagora update --enable turns it back on
+LAGORA_AUTO_UPDATE=0 lagora report ...   # per process; false and off also work
+```
+
+The persisted setting lives in `$XDG_CONFIG_HOME/lagora/update.json`
+(`~/.config/lagora/update.json` by default). It's separate from the login
+config, which the updater never reads or writes.
+
+### Manual
+
+```sh
+lagora update          # check now and apply a newer stable exact version
+lagora update --help
+```
+
+`lagora update` ignores the 24-hour throttle and the disabled setting, prints a
+JSON status line, and exits 0 when it updated or was already current, 1 when
+the install is unsupported, another updater holds the lock, or the update
+failed. Reasons are sanitized codes; raw npm output and credentials never
+appear.
+
+### Supported installs
+
+Self-update, automatic or manual, only touches a canonical `npm install -g`
+of `lagora-cli` on Unix where the global prefix, bin link and package
+directory are owned and writable by the current non-root user and match npm's
+configured global prefix. Everything else still runs every ordinary command but
+never updates itself and makes no registry update requests:
+
+- `sudo` or root installs
+- Windows
+- `npx`
+- project-local dependencies
+- `npm link` or a repository checkout
+- read-only prefixes
+
+npm itself is invoked with `--ignore-scripts`, `--engine-strict` and an exact
+validated version, using your configured registry, `.npmrc` and npm-managed
+auth. CLI and chat tokens are kept out of npm's environment.
+
+### Disk footprint and cleanup
+
+Each applied update is staged inside the prefix and then kept as an immutable
+release under `<prefix>/.lagora-update/releases/<uuid>`. Only the small global
+launcher file is switched, atomically, so commands that are still running, or
+suspended, keep the assets they started with. Old releases are intentionally
+not garbage-collected: a paused process may still need them. Each retained
+release is roughly the size of one unpacked package, about 0.6 MB at the current
+version, so the directory grows by that much per update.
+
+To reclaim the space:
+
+1. Make sure no `lagora` process is running or suspended.
+2. Reinstall normally: `npm install -g lagora-cli`.
+3. Remove `<prefix>/.lagora-update` (find the prefix with `npm prefix -g`).
+
+`npm uninstall -g lagora-cli` alone leaves `.lagora-update` behind;
+remove it by hand as well when uninstalling for good.
+
+Known limits: the updater's lock doesn't coordinate with a separate `npm
+install`/`uninstall` you run at the same time, and a hard kill between the
+launcher switch and the manifest refresh can leave `npm ls -g` showing a stale
+version while the CLI itself already runs the new release. Both are recovered
+by an ordinary reinstall.
+
+## Build and test from this repository
+
+```sh
+npm ci
+npm run build:cli
+npm run test:cli
+npm run pack:cli
+```
+
+The build reuses the repository's esbuild and compiles only the CLI dependency
+graph. `dist/` and this README plus the manifest are the only shipped files.
+Explicit asset allowlists exclude tests, environment files, local data and
+repository evidence. There are zero runtime npm dependencies and no install
+lifecycle script. The root website remains private and independently built.
+
+The runtime test creates a real tarball with `npm pack`, installs it globally
+under a temporary prefix outside the repository, then runs that installed
+`lagora` with temporary HOME/config/data directories and loopback APIs only.
+No npm credentials or registry publishing are needed.

package/dist/help.txt

@@ -0,0 +1,70 @@
+Usage: lagora <command> [options]
+
+Commands:
+  login     Sign in through the browser (Keycloak + activity profile)
+  logout    Revoke and clear CLI login
+  whoami    Show the verified CLI identity
+  tokens    List or revoke your active CLI tokens
+  report    Submit a portable Legato issue bundle
+  search    Search similar issues
+  fetch     Fetch an issue and copy artifacts locally
+  comment   Add an analysis/comment reply
+  status    Update an issue status
+  description Rewrite the issue description
+  suggestion Submit or replace a kernel code suggestion
+  assign    Assign an issue
+  blocker   Link or sync a GitHub PR blocker
+  notifications List or mark remote board notifications read
+  announce  Publish a site-wide feature announcement
+  sdk       Inspect or update the site's prepared SDK packages
+  playground Upload and inspect Playground runs
+  feedback  List, fetch, or resolve site feedback
+  issue     Fetch or update issues
+  verify    Run worker verification
+  keycloak  Plan, apply, or verify safe Keycloak provisioning
+  skill     Install the Legato Agora agent skills
+  help      Show this help
+
+Examples:
+  lagora login
+  lagora report --kernel kernel.py --log error.log --title "lowering failure" --reporter alice
+  lagora tokens list
+  lagora tokens revoke --token <token-id>
+  lagora tokens revoke --all
+  lagora search --query "cgdma Xfer=0 lowering"
+  lagora fetch --issue <issue-id> --out ./issue-work
+  lagora comment --issue <issue-id> --body "Root cause looks like CORE_IR lowering."
+  lagora status --issue <issue-id> --status investigating
+  lagora description --issue <issue-id> --body "Updated reproduction steps."
+  lagora suggestion --issue <issue-id> --file fixed_kernel.py
+  lagora assign --issue <issue-id> --assignee alice
+  lagora blocker add --issue <issue-id> --pr 1234
+  lagora blocker sync --issue <issue-id> --blocker-id <blocker-id>
+  lagora issue notifications
+  lagora issue notifications read --notification <notification-id>
+  lagora feedback list
+  LAGORA_ANNOUNCEMENT_TOKEN=... lagora announce create --title "Playground" --body "Playground is now available." --link /playground
+  LAGORA_SDK_TOKEN=... lagora sdk status
+  LAGORA_SDK_TOKEN=... lagora sdk list --disk
+  LAGORA_SDK_TOKEN=... lagora sdk update --watch
+  lagora playground runtimes
+  lagora playground validate --kernel kernel.py
+  lagora playground run --kernel kernel.py --sdk-name prepared-runtime
+  lagora playground status --run <run-id>
+  lagora playground report --run <run-id> --title "CORE_IR regression"
+  lagora feedback fetch --status open
+  lagora feedback resolve --id <feedback-id>
+  lagora fetch --store /path/to/issue-store --issue <issue-id> --out ./issue-work
+  lagora comment --store /path/to/issue-store --issue <issue-id> --body "Root cause looks like CORE_IR lowering."
+  lagora status --store /path/to/issue-store --issue <issue-id> --status investigating
+  lagora description --store /path/to/issue-store --issue <issue-id> --body "Updated reproduction steps."
+  lagora verify --store /path/to/issue-store --issue <issue-id> --kind lowering --mode real --sdk-branch main
+  lagora keycloak plan --state-fixture fixtures/keycloak/empty-realm.fixture.json
+  lagora keycloak verify --claims-fixture fixtures/keycloak/tenant-claims.fixture.json
+  lagora keycloak verify --live
+  lagora skill install
+
+Targets:
+  Commands talk to https://legato-dev-agora.hyperaccel.net/legato-dev-agora by default.
+  Pass --api-url <url> or set LAGORA_API_URL to use another deployment, and
+  pass --store <path> to work against a local or mounted issue store instead.

package/dist/lagora.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+// packages/cli/src/lagora.ts
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+// packages/cli/src/dispatch.ts
+var aliases = {
+  fetch: "checkout",
+  comment: "comment",
+  status: "status",
+  description: "description",
+  suggestion: "suggestion",
+  assign: "assign",
+  blocker: "blocker",
+  notifications: "notifications"
+};
+var scripts = {
+  report: "report",
+  search: "issue-search",
+  issue: "issue",
+  verify: "verify-issue",
+  announce: "announce",
+  sdk: "sdk",
+  playground: "playground",
+  feedback: "site-feedback",
+  keycloak: "keycloak-provision",
+  skill: "install-skill"
+};
+var authCommands = /* @__PURE__ */ new Set(["login", "logout", "whoami", "tokens"]);
+function commandTarget(command, argv) {
+  if (authCommands.has(command)) return { script: "cli-auth", argv: [command, ...argv] };
+  if (Object.hasOwn(aliases, command)) return { script: "issue", argv: [aliases[command], ...argv] };
+  if (Object.hasOwn(scripts, command)) return { script: scripts[command], argv: [...argv] };
+  throw new Error(`Unknown command: ${command}`);
+}
+
+// packages/cli/src/update.ts
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { accessSync, constants, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+var packageName = "lagora-cli";
+var stable = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var interval = 24 * 60 * 60 * 1e3;
+var UpdateError = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.reason = reason;
+  }
+};
+function isNewerStable(candidate, current) {
+  if (typeof candidate !== "string" || typeof current !== "string") return false;
+  const next = stable.exec(candidate);
+  const previous = stable.exec(current);
+  if (!next || !previous) return false;
+  for (const index of [1, 2, 3]) {
+    const a = BigInt(next[index] ?? "0");
+    const b = BigInt(previous[index] ?? "0");
+    if (a !== b) return a > b;
+  }
+  return false;
+}
+function code(error, expected) {
+  return error instanceof Error && "code" in error && error.code === expected;
+}
+function json(file) {
+  const value = JSON.parse(readFileSync(file, "utf8"));
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new UpdateError("invalid-metadata");
+  return Object.fromEntries(Object.entries(value));
+}
+function settingsPath(env) {
+  return path.join(env.XDG_CONFIG_HOME || path.join(env.HOME || homedir(), ".config"), "lagora", "update.json");
+}
+async function setAutoUpdate(enabled, env = process.env) {
+  const file = settingsPath(env);
+  mkdirSync(path.dirname(file), { recursive: true, mode: 448 });
+  const temporary = `${file}.${randomUUID()}`;
+  try {
+    writeFileSync(temporary, JSON.stringify({ enabled }), { mode: 384, flag: "wx" });
+    renameSync(temporary, file);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+function autoEnabled(env) {
+  if (/^(0|false|off)$/i.test(env.LAGORA_AUTO_UPDATE ?? "")) return false;
+  try {
+    return json(settingsPath(env)).enabled !== false;
+  } catch (error) {
+    if (code(error, "ENOENT")) return true;
+    throw error;
+  }
+}
+function installation(packageRoot) {
+  if (process.platform === "win32" || process.getuid?.() === 0) return void 0;
+  const runtime = path.resolve(packageRoot);
+  const retained = path.basename(path.dirname(runtime)) === "releases" && path.basename(path.resolve(runtime, "../..")) === ".lagora-update";
+  const prefix = path.resolve(runtime, "../../..");
+  const root2 = path.join(prefix, "lib/node_modules", packageName);
+  if (!retained && runtime !== root2) return void 0;
+  try {
+    if (realpathSync(root2) !== root2 || realpathSync(runtime) !== runtime) return void 0;
+    for (let ancestor = root2; ; ancestor = path.dirname(ancestor)) {
+      if (existsSync(path.join(ancestor, ".git"))) return void 0;
+      if (ancestor === path.dirname(ancestor)) break;
+    }
+    for (const directory of [prefix, path.join(prefix, "lib/node_modules"), root2, runtime, path.join(prefix, "bin")]) {
+      const info = lstatSync(directory);
+      if (!info.isDirectory() || info.uid !== process.getuid?.() || (info.mode & 128) === 0) return void 0;
+      accessSync(directory, constants.W_OK);
+    }
+    const manifest = json(path.join(root2, "package.json"));
+    const bin = manifest.bin;
+    if (manifest.name !== packageName || typeof manifest.version !== "string" || !stable.test(manifest.version) || !bin || typeof bin !== "object" || Reflect.get(bin, "lagora") !== "dist/lagora.js" || realpathSync(path.join(prefix, "bin/lagora")) !== path.join(root2, "dist/lagora.js")) return void 0;
+    return { root: root2, prefix, version: manifest.version, state: path.join(prefix, ".lagora-update") };
+  } catch (error) {
+    if (error instanceof Error) return void 0;
+    throw error;
+  }
+}
+function alive(owner) {
+  const pid = Number(owner.split("-")[0]);
+  if (!Number.isSafeInteger(pid) || pid <= 0) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (code(error, "ESRCH")) return false;
+    throw error;
+  }
+}
+function stateDirectory(install) {
+  mkdirSync(install.state, { recursive: true, mode: 448 });
+  const info = lstatSync(install.state);
+  if (!info.isDirectory() || info.uid !== process.getuid?.()) throw new UpdateError("unsafe-state-directory");
+}
+function lock(file) {
+  const owner = `${process.pid}-${randomUUID()}`;
+  try {
+    symlinkSync(owner, file);
+  } catch (error) {
+    if (!code(error, "EEXIST")) throw error;
+    let previous;
+    try {
+      previous = readlinkSync(file);
+    } catch (readError) {
+      if (code(readError, "ENOENT")) return lock(file);
+      throw readError;
+    }
+    if (!/^\d+-[0-9a-f-]{36}$/.test(previous) || alive(previous)) return void 0;
+    const releaseReaper = lock(`${file}.reap-${previous}`);
+    if (!releaseReaper) return void 0;
+    try {
+      try {
+        if (readlinkSync(file) === previous) unlinkSync(file);
+      } catch (readError) {
+        if (!code(readError, "ENOENT")) throw readError;
+      }
+    } finally {
+      releaseReaper();
+    }
+    return lock(file);
+  }
+  return () => {
+    if (readlinkSync(file) === owner) unlinkSync(file);
+  };
+}
+function npmEnvironment(env) {
+  return { NODE_ENV: env.NODE_ENV ?? "production", ...Object.fromEntries(Object.entries(env).filter(([key]) => /^(npm_|path$|home$|userprofile$|appdata$|localappdata$|tmpdir$|temp$|tmp$|systemroot$|comspec$|pathext$|https?_proxy$|no_proxy$|node_extra_ca_certs$|ssl_cert_file$)/i.test(key))) };
+}
+async function npm(args, env, timeout) {
+  try {
+    const result = await execute("npm", [...args, "--fetch-retries=0", "--fetch-timeout=2000", "--update-notifier=false", "--no-audit", "--no-fund"], {
+      cwd: env.HOME || homedir(),
+      env: npmEnvironment(env),
+      timeout,
+      killSignal: "SIGKILL",
+      maxBuffer: 1024 * 1024
+    });
+    return result.stdout.trim();
+  } catch (error) {
+    if (error instanceof Error) throw new UpdateError("npm-unavailable-or-failed");
+    throw error;
+  }
+}
+function promote(install, staged) {
+  const releases = path.join(install.state, "releases");
+  mkdirSync(releases, { recursive: true, mode: 448 });
+  const retained = path.join(releases, randomUUID());
+  renameSync(staged, retained);
+  const launcher = path.join(install.root, "dist/lagora.js");
+  const temporary = `${launcher}.${randomUUID()}`;
+  const manifest = path.join(install.root, "package.json");
+  const metadata = `${manifest}.${randomUUID()}`;
+  const relative = path.relative(path.dirname(launcher), path.join(retained, "dist/lagora.js"));
+  try {
+    writeFileSync(temporary, `#!/usr/bin/env node
+await import(new URL(${JSON.stringify(relative)}, import.meta.url));
+`, { mode: 493, flag: "wx" });
+    writeFileSync(metadata, readFileSync(path.join(retained, "package.json")), { mode: 420, flag: "wx" });
+    renameSync(temporary, launcher);
+    renameSync(metadata, manifest);
+  } finally {
+    rmSync(temporary, { force: true });
+    rmSync(metadata, { force: true });
+  }
+}
+async function runUpdate(options) {
+  const env = options.env ?? process.env;
+  let release;
+  let staging;
+  try {
+    if (options.mode === "auto" && !autoEnabled(env)) return { status: "disabled" };
+    const install = installation(options.packageRoot);
+    if (!install || env.npm_command === "exec") return { status: "unsupported" };
+    stateDirectory(install);
+    release = lock(path.join(install.state, "install"));
+    if (!release) return { status: "busy" };
+    const now = (options.now ?? Date.now)();
+    const state = path.join(install.state, "checked.json");
+    let last;
+    try {
+      last = json(state).at;
+    } catch (error) {
+      if (!code(error, "ENOENT") && !(error instanceof SyntaxError)) throw error;
+    }
+    if (options.mode === "auto" && typeof last === "number" && now >= last && now - last < interval) return { status: "throttled" };
+    writeFileSync(state, JSON.stringify({ at: now }), { mode: 384 });
+    if (realpathSync(await npm(["prefix", "--global"], env, 3e3)) !== install.prefix) return { status: "unsupported" };
+    const raw = JSON.parse(await npm(["view", `${packageName}@latest`, "name", "version", "--json"], env, 4e3));
+    if (!raw || typeof raw !== "object" || Reflect.get(raw, "name") !== packageName) throw new UpdateError("registry-identity-mismatch");
+    const version = Reflect.get(raw, "version");
+    if (typeof version !== "string" || !stable.test(version)) throw new UpdateError("registry-version-invalid");
+    if (!isNewerStable(version, install.version)) return { status: "current", version: install.version };
+    staging = mkdtempSync(path.join(install.state, "stage-"));
+    const globalConfig = await npm(["config", "get", "globalconfig"], env, 3e3);
+    await npm(["install", "--global", "--prefix", staging, "--globalconfig", globalConfig, "--ignore-scripts", "--engine-strict", "--install-strategy=nested", "--package-lock=false", `${packageName}@${version}`], env, 45e3);
+    const staged = path.join(staging, "lib/node_modules", packageName);
+    const manifest = json(path.join(staged, "package.json"));
+    if (manifest.name !== packageName || manifest.version !== version || !manifest.bin || typeof manifest.bin !== "object" || Reflect.get(manifest.bin, "lagora") !== "dist/lagora.js" || !lstatSync(path.join(staged, "dist/lagora.js")).isFile()) throw new UpdateError("installed-identity-mismatch");
+    promote(install, staged);
+    return { status: "updated", version };
+  } catch (error) {
+    if (error instanceof Error) return { status: "failed", reason: error instanceof UpdateError ? error.reason : "update-io-failed" };
+    throw error;
+  } finally {
+    try {
+      if (staging) rmSync(staging, { recursive: true, force: true });
+    } finally {
+      release?.();
+    }
+  }
+}
+async function beforeCommand(argv, packageRoot) {
+  if (argv[0] === "update") {
+    if (argv.length === 2 && ["--enable", "--disable"].includes(argv[1] ?? "")) {
+      await setAutoUpdate(argv[1] === "--enable");
+      console.log(`Automatic updates ${argv[1] === "--enable" ? "enabled" : "disabled"}.`);
+    } else if (argv.length === 2 && ["--help", "-h"].includes(argv[1] ?? "")) {
+      console.log("Usage: lagora update [--enable|--disable]\nUpdates a user-owned global npm install. Automatic updates run after commands, at most daily. LAGORA_AUTO_UPDATE=0 disables automatic updates.");
+    } else if (argv.length > 1) {
+      console.error("Usage: lagora update [--enable|--disable]");
+      process.exitCode = 1;
+    } else {
+      const result = await runUpdate({ packageRoot, mode: "manual" });
+      console.log(JSON.stringify(result));
+      if (!["updated", "current"].includes(result.status)) process.exitCode = 1;
+    }
+    return true;
+  }
+  return false;
+}
+async function afterCommand(packageRoot) {
+  try {
+    const result = await runUpdate({ packageRoot, mode: "auto" });
+    if (result.status === "updated") console.error(`lagora updated to ${result.version}; the next command uses the new version.`);
+    if (result.status === "failed") console.error(`lagora auto-update unavailable (${result.reason}); your command result is unchanged.`);
+  } catch (error) {
+    if (error instanceof Error) console.error("lagora auto-update cleanup failed; your command result is unchanged.");
+    else throw error;
+  }
+}
+
+// packages/cli/src/lagora.ts
+var root = new URL("./", import.meta.url);
+async function run(script, argv) {
+  const child = spawn(process.execPath, [fileURLToPath(new URL(`scripts/${script}.js`, root)), ...argv], { stdio: "inherit" });
+  const result = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code2, signal) => resolve({ code: code2, signal }));
+  });
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    return false;
+  }
+  process.exitCode = result.code ?? 1;
+  return result.code === 0;
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const packageRoot = fileURLToPath(new URL("../", root));
+  if (await beforeCommand(argv, packageRoot)) return;
+  try {
+    await dispatch(argv);
+  } finally {
+    await afterCommand(packageRoot);
+  }
+}
+async function dispatch(argv) {
+  const command = argv[0] ?? "help";
+  if (command === "--version" || command === "-v") {
+    const manifest = JSON.parse(await readFile(new URL("../package.json", root), "utf8"));
+    console.log(manifest.version);
+    return;
+  }
+  if (["help", "--help", "-h"].includes(command)) {
+    process.stdout.write(await readFile(new URL("help.txt", root), "utf8"));
+    return;
+  }
+  const args = argv.slice(1);
+  const target = commandTarget(command, args);
+  if (args.includes("--store")) process.env.AGORA_ISSUE_STORE_MODE = "isolated";
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(await readFile(new URL(command === "report" ? "report-help.txt" : "help.txt", root), "utf8"));
+    return;
+  }
+  if (!authCommands.has(command) && !await run("cli-auth", ["require-auth", command, ...args])) return;
+  if (["sdk", "announce"].includes(command) && !args.includes("--api-url")) {
+    const { LagoraCliConfigStore } = await import("./scripts/cli-config-IA7EOSYD.js");
+    target.argv.push("--api-url", (await new LagoraCliConfigStore().apiSession(void 0)).apiUrl);
+  }
+  await run(target.script, target.argv);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/dist/report-help.txt

@@ -0,0 +1,5 @@
+Usage: lagora report --kernel path --title title --reporter name [--log path] [--description text | --description-file path] [--api-url url | --store path] [--idempotency-key key] [--auto-lowering] [--sdk-root path] [--python python3] [--stages MLIR,CORE_IR] [--kernel-function name]
+
+Creates a portable issue bundle under issue-store/issues/<id>/ by default.
+Pass --api-url to submit to the internal Agora server.
+Pass --store to write into a local or mounted issue repository.