lagora-cli 1.1.0

package/dist/scripts/playground.js

@@ -0,0 +1,408 @@
+import {
+  LagoraCliConfigStore,
+  apiSession,
+  baseApiUrl,
+  readJsonFromApi,
+  requestHeaders,
+  writeJsonToApi
+} from "./chunk-AZ3EEBVD.js";
+import "./chunk-TJZVQYBL.js";
+
+// scripts/playground.ts
+import { readFile } from "node:fs/promises";
+import path2 from "node:path";
+
+// scripts/playground-submission-contract.ts
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function hasPlaygroundContract(kernelPath) {
+  const scriptsDir = import.meta.dirname;
+  try {
+    const { stdout } = await execFileAsync("python3", ["-c", `
+import json, sys
+from pathlib import Path
+sys.path.insert(0, ${JSON.stringify(scriptsDir)})
+from agora_playground_harness import has_playground_contract
+from legato_runner_launchers import kernel_has_launcher, statically_decorated_kernel_names
+
+path = Path(sys.argv[1])
+kernels = sorted(statically_decorated_kernel_names(path))
+print(json.dumps({
+    "ok": has_playground_contract(path),
+    "kernels": kernels,
+    "launcher": kernel_has_launcher(path),
+}))
+`.trim(), path.resolve(kernelPath)]);
+    const payload = JSON.parse(stdout);
+    if (!isRecord(payload) || !Array.isArray(payload.kernels) || !payload.kernels.every((item) => typeof item === "string")) {
+      return { ok: false, error: "Production dispatch returned an invalid submission verdict" };
+    }
+    if (payload.ok === true) return { ok: true, kernels: payload.kernels };
+    if (payload.kernels.length === 0) {
+      return { ok: false, error: "submission must define a module-level @legato.compile or @legato.primitive kernel" };
+    }
+    if (payload.launcher === true) {
+      return { ok: false, error: "submission must not define a launcher; the Agora harness owns stage selection" };
+    }
+    return { ok: false, error: "submission does not satisfy the Agora Playground contract" };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: `cannot inspect Playground submission: ${detail}` };
+  }
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// scripts/playground-api-client.ts
+async function createPlaygroundRun(input) {
+  const payload = await writeJsonToApi(`${baseApiUrl(input.session.apiUrl)}/api/playground/runs`, "POST", {
+    filename: input.filename,
+    source: input.source,
+    ...input.sdkName ? { sdkName: input.sdkName } : {},
+    ...input.legatoSdkName ? { legatoSdkName: input.legatoSdkName } : {},
+    ...input.legatoVersion ? { legatoVersion: input.legatoVersion } : {},
+    ...input.sdkVersion ? { sdkVersion: input.sdkVersion } : {},
+    mode: input.mode,
+    profile: input.profile
+  }, input.session);
+  return readRunEnvelope(payload);
+}
+async function readPlaygroundRun(session, id) {
+  const payload = await readJsonFromApi(
+    `${baseApiUrl(session.apiUrl)}/api/playground/runs/${encodeURIComponent(id)}`,
+    session
+  );
+  if (!isRecord2(payload)) throw new Error("Playground API returned an invalid run detail");
+  const source = Reflect.get(payload, "source");
+  const log = Reflect.get(payload, "log");
+  const artifacts = Reflect.get(payload, "artifacts");
+  if (typeof source !== "string" || typeof log !== "string" || !isStringArray(artifacts)) {
+    throw new Error("Playground API returned an invalid run detail");
+  }
+  return {
+    run: readRun(Reflect.get(payload, "run")),
+    source,
+    log,
+    artifacts
+  };
+}
+async function listPlaygroundRuntimes(session) {
+  const payload = await readJsonFromApi(`${baseApiUrl(session.apiUrl)}/api/playground/runtimes`, session);
+  if (!isRecord2(payload)) throw new Error("Playground API returned an invalid runtime list");
+  const runtimes = Reflect.get(payload, "runtimes");
+  if (!Array.isArray(runtimes)) throw new Error("Playground API returned an invalid runtime list");
+  return runtimes.map(readRuntime);
+}
+async function reportPlaygroundRun(input) {
+  if (input.detail.run.status !== "complete" && input.detail.run.status !== "error") {
+    throw new Error(`Playground run ${input.detail.run.id} must finish before it can be reported`);
+  }
+  const endpoint = `${baseApiUrl(input.session.apiUrl)}/api/report-bundles`;
+  const form = new FormData();
+  form.set("title", input.title);
+  form.set("reporter", input.reporter);
+  form.set("description", input.description);
+  form.set("tags", input.tags);
+  form.set("idempotencyKey", `playground-run-${input.detail.run.id}`);
+  form.set("gitMetadata", JSON.stringify({}));
+  form.set("environmentMetadata", JSON.stringify(playgroundEnvironment(input.detail)));
+  form.set("kernelFile", new File([input.detail.source], input.detail.run.filename, { type: "text/x-python" }));
+  if (input.detail.log) {
+    form.set("errorLogFile", new File([input.detail.log], `${input.detail.run.id}.log`, { type: "text/plain" }));
+  }
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: requestHeaders(input.session),
+    body: form
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`API request failed: HTTP ${response.status} ${body.slice(0, 240)}`);
+  }
+  const payload = await response.json();
+  if (!isRecord2(payload)) throw new Error("Report API returned an invalid response");
+  return {
+    issueId: requiredString(payload, "issueId"),
+    bundleId: requiredString(payload, "bundleId"),
+    duplicate: Reflect.get(payload, "duplicate") === true,
+    ...optionalStrings(payload, ["githubIssueUrl"])
+  };
+}
+function playgroundEnvironment(detail) {
+  const run = detail.run;
+  return {
+    playgroundRunId: run.id,
+    playgroundMode: run.mode,
+    playgroundProfile: run.profile,
+    playgroundStatus: run.status,
+    lower: run.lower,
+    fsim: run.fsim,
+    value: run.value,
+    sdkName: run.sdkName,
+    sdkBranch: run.sdkBranch,
+    ...run.sdkCommitSha ? { sdkCommitSha: run.sdkCommitSha } : {},
+    ...run.legatoSdkName ? { legatoSdkName: run.legatoSdkName } : {},
+    ...run.legatoSdkBranch ? { legatoSdkBranch: run.legatoSdkBranch } : {},
+    ...run.legatoSdkCommitSha ? { legatoSdkCommitSha: run.legatoSdkCommitSha } : {},
+    ...run.valueDetail ? { valueDetail: run.valueDetail } : {},
+    ...run.error ? { error: run.error } : {},
+    ...detail.artifacts.length > 0 ? { playgroundArtifacts: detail.artifacts.join(",") } : {}
+  };
+}
+function readRunEnvelope(payload) {
+  if (!isRecord2(payload)) throw new Error("Playground API returned an invalid response");
+  if (Reflect.get(payload, "preparing") === true) {
+    const percent = Reflect.get(payload, "percent");
+    const step = Reflect.get(payload, "step");
+    throw new Error(`Runtime is preparing${typeof percent === "number" ? ` (${percent}%)` : ""}${typeof step === "string" ? `: ${step}` : ""}; rerun the command when preparation completes`);
+  }
+  return readRun(Reflect.get(payload, "run"));
+}
+function readRun(value) {
+  if (!isRecord2(value)) throw new Error("Playground API returned an invalid run");
+  const id = requiredString(value, "id");
+  const filename = requiredString(value, "filename");
+  const mode = enumString(value, "mode", ["lower", "fsim"]);
+  const profile = enumString(value, "profile", ["none", "cycle", "hapti", "full"]);
+  const status = enumString(value, "status", ["queued", "running", "complete", "error"]);
+  const lower = enumString(value, "lower", ["pending", "running", "pass", "fail"]);
+  const fsim = enumString(value, "fsim", ["pending", "running", "pass", "fail"]);
+  const verdict = enumString(value, "value", ["pending", "running", "pass", "fail"]);
+  return {
+    id,
+    filename,
+    mode,
+    profile,
+    status,
+    lower,
+    fsim,
+    value: verdict,
+    sdkName: requiredString(value, "sdkName"),
+    sdkBranch: requiredString(value, "sdkBranch"),
+    ...optionalStrings(value, [
+      "sdkCommitSha",
+      "legatoSdkName",
+      "legatoSdkBranch",
+      "legatoSdkCommitSha",
+      "valueDetail",
+      "startedAt",
+      "completedAt",
+      "error"
+    ]),
+    createdAt: requiredString(value, "createdAt")
+  };
+}
+function readRuntime(value) {
+  if (!isRecord2(value)) throw new Error("Playground API returned an invalid runtime");
+  return {
+    name: requiredString(value, "name"),
+    label: requiredString(value, "label"),
+    compilerLabel: requiredString(value, "compilerLabel"),
+    status: enumString(value, "status", ["not_prepared", "preparing", "ready", "failed"]),
+    branch: requiredString(value, "branch"),
+    ...optionalStrings(value, ["commitSha", "legatoVersion", "sdkVersion"])
+  };
+}
+function requiredString(value, key) {
+  const field = Reflect.get(value, key);
+  if (typeof field !== "string" || !field) throw new Error(`Playground API omitted ${key}`);
+  return field;
+}
+function optionalStrings(value, keys) {
+  return Object.fromEntries(keys.flatMap((key) => {
+    const field = Reflect.get(value, key);
+    return typeof field === "string" && field ? [[key, field]] : [];
+  }));
+}
+function enumString(value, key, allowed) {
+  const field = requiredString(value, key);
+  if (!allowed.includes(field)) throw new Error(`Playground API returned invalid ${key}: ${field}`);
+  return field;
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+
+// scripts/playground.ts
+var USAGE = `Usage:
+  lagora playground validate --kernel path
+  lagora playground runtimes [--api-url url] [--json]
+  lagora playground run --kernel path (--sdk-name name | --legato version --sdk version) [--legato-sdk-name name] [--mode lower|fsim] [--profile none|cycle|hapti|full] [--api-url url] [--json]
+  lagora playground status --run id [--api-url url] [--json]
+  lagora playground report --run id --title title [--reporter name] [--description text] [--tags tags] [--api-url url] [--json]`;
+var VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "--api-url",
+  "--kernel",
+  "--run",
+  "--title",
+  "--reporter",
+  "--description",
+  "--tags",
+  "--sdk-name",
+  "--legato-sdk-name",
+  "--legato",
+  "--sdk",
+  "--mode",
+  "--profile"
+]);
+function parsePlaygroundArgs(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("--")) throw new Error(`Unexpected argument: ${option}`);
+    if (option === "--json") {
+      flags.add(option);
+      continue;
+    }
+    if (!VALUE_OPTIONS.has(option)) throw new Error(`Unknown option: ${option}`);
+    const value = argv[index + 1];
+    if (!value || value.startsWith("--")) throw new Error(`${option} requires a value`);
+    values.set(option, value);
+    index += 1;
+  }
+  const mode = values.get("--mode") ?? "lower";
+  const profile = values.get("--profile") ?? "none";
+  if (mode !== "lower" && mode !== "fsim") throw new Error(`Invalid --mode: ${mode}`);
+  if (!["none", "cycle", "hapti", "full"].includes(profile)) throw new Error(`Invalid --profile: ${profile}`);
+  return {
+    command: argv[0] ?? "help",
+    apiUrl: values.get("--api-url"),
+    kernel: values.get("--kernel"),
+    runId: values.get("--run"),
+    title: values.get("--title"),
+    reporter: values.get("--reporter"),
+    description: values.get("--description") ?? "",
+    tags: values.get("--tags") ?? "",
+    sdkName: values.get("--sdk-name"),
+    legatoSdkName: values.get("--legato-sdk-name"),
+    legatoVersion: values.get("--legato"),
+    sdkVersion: values.get("--sdk"),
+    mode,
+    profile,
+    json: flags.has("--json")
+  };
+}
+async function runPlaygroundCli(argv, config = new LagoraCliConfigStore()) {
+  const args = parsePlaygroundArgs(argv);
+  if (args.command === "help" || args.command === "--help" || args.command === "-h") {
+    console.log(USAGE);
+    return;
+  }
+  if (!["validate", "runtimes", "run", "status", "report"].includes(args.command)) throw new Error(USAGE);
+  if (args.command === "validate") {
+    if (!args.kernel) throw new Error("playground validate requires --kernel");
+    const contract = await hasPlaygroundContract(args.kernel);
+    if (!contract.ok) throw new Error(contract.error);
+    if (args.json) console.log(JSON.stringify(contract));
+    else console.log(`ok: ${args.kernel} is harness-compatible`);
+    return;
+  }
+  if (args.command === "run") {
+    const usesPreparedName = Boolean(args.sdkName || args.legatoSdkName);
+    const usesVersionPair = Boolean(args.legatoVersion || args.sdkVersion);
+    if (usesPreparedName && usesVersionPair) {
+      throw new Error("Choose either --sdk-name (with optional --legato-sdk-name) or --legato with --sdk");
+    }
+  }
+  const stored = await config.apiSession(args.apiUrl);
+  const session = apiSession(stored.apiUrl, { cookie: stored.cookie, token: stored.token });
+  if (args.command === "runtimes") {
+    const runtimes = await listPlaygroundRuntimes(session);
+    if (args.json) {
+      console.log(JSON.stringify({ runtimes }));
+      return;
+    }
+    for (const runtime of runtimes) {
+      console.log(`${runtime.name}	${runtime.status}	legato=${runtime.legatoVersion ?? "-"}	sdk=${runtime.sdkVersion ?? "-"}`);
+    }
+    return;
+  }
+  if (args.command === "run") {
+    if (!args.kernel) throw new Error("playground run requires --kernel");
+    if (!args.sdkName && !(args.legatoVersion && args.sdkVersion)) {
+      throw new Error("playground run requires --sdk-name or both --legato and --sdk");
+    }
+    const source = await readFile(args.kernel, "utf8");
+    const run = await createPlaygroundRun({
+      session,
+      filename: path2.basename(args.kernel),
+      source,
+      sdkName: args.sdkName,
+      legatoSdkName: args.legatoSdkName,
+      legatoVersion: args.legatoVersion,
+      sdkVersion: args.sdkVersion,
+      mode: args.mode,
+      profile: args.profile
+    });
+    const output = { ...run, url: `${baseApiUrl(session.apiUrl)}/playground?run=${encodeURIComponent(run.id)}` };
+    if (args.json) console.log(JSON.stringify(output));
+    else {
+      console.log(`Playground run ${run.id} queued`);
+      console.log(`Open: ${output.url}`);
+      console.log(`Status: lagora playground status --run ${run.id}`);
+    }
+    return;
+  }
+  if (args.command === "status") {
+    if (!args.runId) throw new Error("playground status requires --run");
+    const detail = await readPlaygroundRun(session, args.runId);
+    if (args.json) console.log(JSON.stringify(detail));
+    else printRunDetail(detail, session.apiUrl);
+    return;
+  }
+  if (args.command === "report") {
+    if (!args.runId) throw new Error("playground report requires --run");
+    if (!args.title) throw new Error("playground report requires --title");
+    const detail = await readPlaygroundRun(session, args.runId);
+    const reporter = await config.author(args.reporter);
+    const issue = await reportPlaygroundRun({
+      session,
+      detail,
+      title: args.title,
+      reporter,
+      description: args.description,
+      tags: args.tags
+    });
+    const output = {
+      ...issue,
+      runId: args.runId,
+      url: issue.githubIssueUrl ?? `${baseApiUrl(session.apiUrl)}/issues/${encodeURIComponent(issue.issueId)}`
+    };
+    if (args.json) console.log(JSON.stringify(output));
+    else {
+      console.log(`${issue.duplicate ? "Matched existing" : "Created"} issue ${issue.issueId} from Playground run ${args.runId}`);
+      console.log(`Open: ${output.url}`);
+    }
+    return;
+  }
+  throw new Error(USAGE);
+}
+function printRunDetail(detail, apiUrl) {
+  const run = detail.run;
+  console.log(`${run.id}  ${run.status}  lower=${run.lower} fsim=${run.fsim} value=${run.value}`);
+  console.log(`Runtime: ${run.sdkName}${run.legatoSdkName ? ` (legato: ${run.legatoSdkName})` : ""}`);
+  console.log(`Open: ${baseApiUrl(apiUrl)}/playground?run=${encodeURIComponent(run.id)}`);
+  if (detail.artifacts.length > 0) {
+    console.log("Artifacts:");
+    for (const artifact of detail.artifacts) console.log(`  ${artifact}`);
+  }
+  if (run.valueDetail) console.log(`Value detail: ${run.valueDetail}`);
+  if (run.error) console.log(`Error: ${run.error}`);
+}
+if (true) {
+  runPlaygroundCli(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+}
+export {
+  parsePlaygroundArgs,
+  runPlaygroundCli
+};

package/dist/scripts/report-bundle-sync-3U7QTP4Z.js

@@ -0,0 +1,215 @@
+import {
+  configuredGithubToken,
+  gitEnv
+} from "./chunk-2EAJVB5D.js";
+
+// lib/server/report-bundle-sync.ts
+import { execFile } from "node:child_process";
+import { mkdir, readdir, readFile, rename, writeFile } from "node:fs/promises";
+import https from "node:https";
+import path from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function prepareGitBackedIssueStore() {
+  const config = await gitConfig();
+  if (!config) return;
+  await mkdir(config.worktree, { recursive: true });
+  if (await hasGitDirectory(config.worktree)) return;
+  await prepareEmptyCloneTarget(config.worktree);
+  await gitCommand(config, ["clone", "--branch", config.branch, config.remote, config.worktree]);
+}
+async function prepareEmptyCloneTarget(worktree) {
+  await mkdir(worktree, { recursive: true });
+  const entries = await readdir(worktree);
+  if (entries.length === 0) return void 0;
+  const backupPath = `${worktree}.pre-clone-${Date.now()}-${process.pid}`;
+  await rename(worktree, backupPath);
+  await mkdir(worktree, { recursive: true });
+  return backupPath;
+}
+async function syncStoredReportBundle(stored, intake) {
+  const firstCommit = await commitBundle(stored, `Add Legato issue ${stored.canonicalIssueId} [skip ci]`);
+  if (!firstCommit) return stored;
+  const github = await createGitHubIssue(stored, intake, firstCommit);
+  const patched = await patchIssueMetadata(stored, firstCommit, github);
+  if (patched) {
+    await commitBundle(stored, `Link Legato issue ${stored.canonicalIssueId} metadata [skip ci]`);
+  }
+  return {
+    ...stored,
+    storeCommitSha: firstCommit.commitSha,
+    storeBundleUrl: firstCommit.bundleUrl,
+    githubIssueUrl: github?.issueUrl,
+    githubIssueNumber: github?.issueNumber
+  };
+}
+async function deleteStoredReportBundle(issueId) {
+  assertSafeIssueId(issueId);
+  const config = await gitConfig();
+  if (!config) return false;
+  await prepareGitBackedIssueStore();
+  await gitCommand(config, ["-C", config.worktree, "config", "user.name", config.authorName]);
+  await gitCommand(config, ["-C", config.worktree, "config", "user.email", config.authorEmail]);
+  await gitCommand(config, ["-C", config.worktree, "pull", "--rebase", "--autostash", "origin", config.branch]);
+  await gitCommand(config, ["-C", config.worktree, "rm", "-r", "--ignore-unmatch", "--", path.posix.join("issues", issueId)]);
+  const hasDiff = await hasStagedDiff(config);
+  if (!hasDiff) return false;
+  await gitCommand(config, ["-C", config.worktree, "commit", "-m", `Delete Legato issue ${issueId} [skip ci]`]);
+  await gitCommand(config, ["-C", config.worktree, "push", "origin", config.branch]);
+  return true;
+}
+function assertSafeIssueId(issueId) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(issueId)) {
+    throw new Error(`Unsafe issue id: ${issueId}`);
+  }
+}
+async function commitBundle(stored, message) {
+  const config = await gitConfig();
+  if (!config) return void 0;
+  await prepareGitBackedIssueStore();
+  const changedPaths = stored.changedPaths.map((changedPath) => path.relative(config.worktree, changedPath));
+  await gitCommand(config, ["-C", config.worktree, "config", "user.name", config.authorName]);
+  await gitCommand(config, ["-C", config.worktree, "config", "user.email", config.authorEmail]);
+  await gitCommand(config, ["-C", config.worktree, "pull", "--rebase", "--autostash", "origin", config.branch]);
+  await gitCommand(config, ["-C", config.worktree, "add", "--", ...changedPaths]);
+  const hasDiff = await hasStagedDiff(config);
+  if (!hasDiff) {
+    const head = await gitOutput(config, ["-C", config.worktree, "rev-parse", "HEAD"]);
+    return { commitSha: head, bundleUrl: bundleUrl(config.repository, head, stored.bundlePath) };
+  }
+  await gitCommand(config, ["-C", config.worktree, "commit", "-m", message]);
+  await gitCommand(config, ["-C", config.worktree, "push", "origin", config.branch]);
+  const commitSha = await gitOutput(config, ["-C", config.worktree, "rev-parse", "HEAD"]);
+  return { commitSha, bundleUrl: bundleUrl(config.repository, commitSha, stored.bundlePath) };
+}
+async function createGitHubIssue(stored, intake, commit) {
+  const repository = process.env.AGORA_GITHUB_REPOSITORY;
+  const token = await configuredGithubToken();
+  if (!repository || !token || stored.duplicate) return void 0;
+  const response = await githubJson({
+    repository,
+    token,
+    path: `/repos/${repository}/issues`,
+    body: {
+      title: `[Legato] ${intake.title}`,
+      labels: ["legato", "agora", ...intake.tags],
+      body: [
+        `Reporter: ${intake.reporter}`,
+        `Bundle: ${commit.bundleUrl ?? stored.bundlePath}`,
+        "",
+        intake.description
+      ].join("\n")
+    }
+  });
+  if (typeof response.number !== "number" || typeof response.html_url !== "string") {
+    throw new Error("GitHub issue response did not include number/html_url");
+  }
+  return { repository, issueNumber: response.number, issueUrl: response.html_url };
+}
+async function patchIssueMetadata(stored, commit, github) {
+  const raw = await readFile(stored.issueJsonPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
+  const current = parsed;
+  current.store = {
+    ...isRecord(current.store) ? current.store : {},
+    commitSha: commit.commitSha,
+    bundlePath: stored.bundlePath,
+    bundleUrl: commit.bundleUrl
+  };
+  if (github) {
+    current.github = {
+      repository: github.repository,
+      issueNumber: github.issueNumber,
+      issueUrl: github.issueUrl,
+      createdBy: "legato-dev-agora",
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  await writeFile(stored.issueJsonPath, `${JSON.stringify(current, null, 2)}
+`);
+  return true;
+}
+async function gitConfig() {
+  const worktree = process.env.AGORA_GIT_WORKTREE;
+  const remote = process.env.AGORA_GIT_REMOTE;
+  if (!worktree || !remote) return void 0;
+  return {
+    worktree: path.resolve(worktree),
+    remote,
+    branch: process.env.AGORA_GIT_BRANCH ?? "main",
+    repository: process.env.AGORA_GITHUB_REPOSITORY,
+    token: await configuredGithubToken(),
+    authorName: process.env.AGORA_GIT_AUTHOR_NAME ?? "Legato Dev Agora",
+    authorEmail: process.env.AGORA_GIT_AUTHOR_EMAIL ?? "legato-dev-agora@hyperaccel.net"
+  };
+}
+async function hasGitDirectory(worktree) {
+  try {
+    await execFileAsync("git", ["-C", worktree, "rev-parse", "--is-inside-work-tree"]);
+    return true;
+  } catch (error) {
+    if (error instanceof Error) return false;
+    throw error;
+  }
+}
+async function hasStagedDiff(config) {
+  try {
+    await gitCommand(config, ["-C", config.worktree, "diff", "--cached", "--quiet"]);
+    return false;
+  } catch (error) {
+    if (error instanceof Error) return true;
+    throw error;
+  }
+}
+async function gitCommand(config, args) {
+  await execFileAsync("git", [...args], { env: gitEnv(config.token) });
+}
+async function gitOutput(config, args) {
+  const output = await execFileAsync("git", [...args], { env: gitEnv(config.token) });
+  return output.stdout.trim();
+}
+function bundleUrl(repository, commitSha, bundlePath) {
+  return repository ? `https://github.com/${repository}/tree/${commitSha}/${bundlePath}` : void 0;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function githubJson(input) {
+  const payload = JSON.stringify(input.body);
+  return new Promise((resolve, reject) => {
+    const request = https.request({
+      method: "POST",
+      hostname: "api.github.com",
+      path: input.path,
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${input.token}`,
+        "Content-Length": Buffer.byteLength(payload),
+        "Content-Type": "application/json",
+        "User-Agent": "legato-dev-agora",
+        "X-GitHub-Api-Version": "2022-11-28"
+      }
+    }, (response) => {
+      const chunks = [];
+      response.on("data", (chunk) => chunks.push(chunk));
+      response.on("end", () => {
+        const text = Buffer.concat(chunks).toString("utf8");
+        if (!response.statusCode || response.statusCode < 200 || response.statusCode >= 300) {
+          reject(new Error(`GitHub API failed ${response.statusCode}: ${text}`));
+          return;
+        }
+        resolve(JSON.parse(text));
+      });
+    });
+    request.on("error", reject);
+    request.write(payload);
+    request.end();
+  });
+}
+export {
+  deleteStoredReportBundle,
+  prepareEmptyCloneTarget,
+  prepareGitBackedIssueStore,
+  syncStoredReportBundle
+};