@codyswann/lisa 4.27.6 → 4.27.8

package/typescript/copy-overwrite/scripts/nightly-e2e-provider-github-jira.mjs

@@ -0,0 +1,296 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** GitHub and Jira adapters for combined nightly-E2E tracking. */
+import { CONDITION_MARKER } from "./reconcile-nightly-e2e-tracking.mjs";
+import { readback, refuse, required } from "./nightly-e2e-provider-support.mjs";
+
+const MAX_GITHUB_PAGES = 10;
+const MAX_JIRA_PAGES = 3;
+
+/** Return whether a GitHub issue has the strict REST identity shape. */
+function isGitHubIssue(issue) {
+  return (
+    issue !== null &&
+    typeof issue === "object" &&
+    Number.isSafeInteger(issue.number) &&
+    issue.number > 0 &&
+    typeof issue.node_id === "string" &&
+    issue.node_id !== "" &&
+    (typeof issue.body === "string" || issue.body === null)
+  );
+}
+
+/** Build GitHub's issue adapter over the injected JSON transport. */
+export function githubAdapter(input) {
+  const destination = "github";
+  const repository = required(input, destination, "GITHUB_REPOSITORY");
+  const token = required(input, destination, "PROVIDER_TOKEN");
+  const [owner, repo, extra] = repository.split("/");
+  if (!owner || !repo || extra) refuse(destination, "configuration");
+  const base = `https://api.github.com/repos/${repository}/issues`;
+  const headers = { Authorization: `Bearer ${token}` };
+  const numbers = new Map();
+  const list = async (operation = "list") => {
+    const issues = [];
+    for (let page = 1; page <= MAX_GITHUB_PAGES; page += 1) {
+      const raw = await input.request({
+        operation,
+        url: `${base}?state=open&per_page=100&page=${page}`,
+        options: { method: "GET", headers },
+      });
+      if (!Array.isArray(raw) || !raw.every(isGitHubIssue)) {
+        refuse(destination, operation, "malformed response");
+      }
+      issues.push(...raw);
+      if (raw.length < 100) break;
+      if (page === MAX_GITHUB_PAGES) {
+        refuse(destination, operation, "result overflow");
+      }
+    }
+    return issues
+      .filter(
+        issue => !issue.pull_request && issue.body?.includes(CONDITION_MARKER)
+      )
+      .map(issue => {
+        const id = issue.node_id ?? String(issue.number);
+        numbers.set(id, issue.number);
+        return { id, marker: CONDITION_MARKER, pinned: false };
+      });
+  };
+  return githubActions(input, { destination, base, headers, numbers, list });
+}
+
+/** Materialize GitHub's write operations around the shared readback. */
+function githubActions(input, context) {
+  const { destination, base, headers, numbers, list } = context;
+  return {
+    async list() {
+      return list();
+    },
+    async create(draft) {
+      const issue = await input.request({
+        operation: "create",
+        url: base,
+        options: {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ title: draft.title, body: draft.body }),
+        },
+      });
+      const id = issue?.node_id ?? String(issue?.number ?? "");
+      if (!id) refuse(destination, "create", "missing issue identity");
+      return readback(destination, list, id, true);
+    },
+    async refresh(id, draft) {
+      const number = numbers.get(id);
+      if (!number) refuse(destination, "refresh", "unknown issue identity");
+      await input.request({
+        operation: "refresh",
+        url: `${base}/${number}`,
+        options: {
+          method: "PATCH",
+          headers,
+          body: JSON.stringify({ title: draft.title, body: draft.body }),
+        },
+      });
+      return readback(destination, list, id, true);
+    },
+    async close(id) {
+      const number = numbers.get(id);
+      if (!number) refuse(destination, "close", "unknown issue identity");
+      await input.request({
+        operation: "close",
+        url: `${base}/${number}`,
+        options: { method: "PATCH", headers, body: '{"state":"closed"}' },
+      });
+      await readback(destination, list, id, false);
+    },
+    async pin(id) {
+      await githubPin(input, headers, "pin", id);
+      await readback(destination, list, id, true);
+    },
+    async unpin(id) {
+      await githubPin(input, headers, "unpin", id);
+    },
+  };
+}
+
+/** Invoke one GitHub pin lifecycle mutation. */
+async function githubPin(input, headers, operation, id) {
+  const field = operation === "pin" ? "pinIssue" : "unpinIssue";
+  const query =
+    operation === "pin"
+      ? "mutation($id:ID!){pinIssue(input:{issueId:$id}){issue{id}}}"
+      : "mutation($id:ID!){unpinIssue(input:{issueId:$id}){issue{id}}}";
+  const raw = await input.request({
+    operation,
+    url: "https://api.github.com/graphql",
+    options: {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query, variables: { id } }),
+    },
+  });
+  const errorsValid =
+    raw?.errors === undefined ||
+    (Array.isArray(raw.errors) && raw.errors.length === 0);
+  if (
+    !errorsValid ||
+    raw?.data === null ||
+    typeof raw?.data !== "object" ||
+    raw.data[field]?.issue?.id !== id
+  ) {
+    refuse("github", operation, "issue identity authority");
+  }
+}
+
+/** Read all bounded Jira search pages through the enhanced-search API. */
+async function jiraSearch(input, operation, base, headers, jql) {
+  const issues = [];
+  const tokens = new Set();
+  let nextPageToken;
+  for (let page = 1; page <= MAX_JIRA_PAGES; page += 1) {
+    const requestBody = {
+      jql,
+      fields: ["description"],
+      maxResults: 100,
+      ...(nextPageToken === undefined ? {} : { nextPageToken }),
+    };
+    const raw = await input.request({
+      operation,
+      url: `${base}/rest/api/3/search/jql`,
+      options: {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+      },
+    });
+    if (!Array.isArray(raw?.issues) || typeof raw.isLast !== "boolean") {
+      refuse("jira", operation, "malformed response");
+    }
+    issues.push(...raw.issues);
+    if (raw.isLast) break;
+    if (
+      typeof raw.nextPageToken !== "string" ||
+      raw.nextPageToken === "" ||
+      tokens.has(raw.nextPageToken) ||
+      page === MAX_JIRA_PAGES
+    ) {
+      refuse("jira", operation, "pagination authority");
+    }
+    tokens.add(raw.nextPageToken);
+    nextPageToken = raw.nextPageToken;
+  }
+  return issues;
+}
+
+/** Build Jira's issue adapter over the injected JSON transport. */
+export function jiraAdapter(input) {
+  const destination = "jira";
+  const base = required(input, destination, "JIRA_BASE_URL").replace(
+    /\/$/u,
+    ""
+  );
+  const email = required(input, destination, "JIRA_USER_EMAIL");
+  const project = required(input, destination, "JIRA_PROJECT_KEY");
+  const token = required(input, destination, "PROVIDER_TOKEN");
+  const credentials = Buffer.from(`${email}:${token}`).toString("base64");
+  const headers = {
+    Authorization: `Basic ${credentials}`,
+    "Content-Type": "application/json",
+  };
+  const list = async (operation = "list") => {
+    const marker = JSON.stringify(`"${CONDITION_MARKER}"`);
+    const jql =
+      `project = ${JSON.stringify(project)} AND statusCategory != Done AND ` +
+      `description ~ ${marker}`;
+    const issues = await jiraSearch(input, operation, base, headers, jql);
+    return issues
+      .filter(issue => issue.fields?.description?.includes(CONDITION_MARKER))
+      .map(issue => ({
+        id: issue.key,
+        marker: CONDITION_MARKER,
+        pinned: false,
+      }));
+  };
+  const createFields = draft => ({
+    project: { key: project },
+    summary: draft.title,
+    description: draft.body,
+    issuetype: { name: "Bug" },
+    labels: ["nightly-e2e", "automation"],
+  });
+  const updateFields = draft => ({
+    summary: draft.title,
+    description: draft.body,
+  });
+  return jiraActions(input, {
+    destination,
+    base,
+    headers,
+    list,
+    createFields,
+    updateFields,
+  });
+}
+
+/** Materialize Jira's write operations around the shared readback. */
+function jiraActions(input, context) {
+  const { destination, base, headers, list, createFields, updateFields } =
+    context;
+  return {
+    async list() {
+      return list();
+    },
+    async create(draft) {
+      const issue = await input.request({
+        operation: "create",
+        url: `${base}/rest/api/2/issue`,
+        options: {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ fields: createFields(draft) }),
+        },
+      });
+      if (!issue?.key) refuse(destination, "create", "missing issue identity");
+      return readback(destination, list, issue.key, true);
+    },
+    async refresh(id, draft) {
+      await input.request({
+        operation: "refresh",
+        url: `${base}/rest/api/2/issue/${id}`,
+        options: {
+          method: "PUT",
+          headers,
+          body: JSON.stringify({ fields: updateFields(draft) }),
+        },
+      });
+      return readback(destination, list, id, true);
+    },
+    async close(id) {
+      const url = `${base}/rest/api/2/issue/${id}/transitions`;
+      const raw = await input.request({
+        operation: "close",
+        url,
+        options: { headers },
+      });
+      const done = (raw?.transitions ?? []).filter(
+        item => item.to?.statusCategory?.key === "done"
+      );
+      if (done.length !== 1) {
+        refuse(destination, "close", "done transition unavailable");
+      }
+      await input.request({
+        operation: "close",
+        url,
+        options: {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ transition: { id: done[0].id } }),
+        },
+      });
+      await readback(destination, list, id, false);
+    },
+  };
+}

package/typescript/copy-overwrite/scripts/nightly-e2e-provider-linear-sentry.mjs

@@ -0,0 +1,283 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Linear and Sentry adapters for combined nightly-E2E tracking. */
+import { CONDITION_MARKER } from "./reconcile-nightly-e2e-tracking.mjs";
+import { readback, refuse, required } from "./nightly-e2e-provider-support.mjs";
+
+const MARKER_TAG = "lisa_nightly_e2e_condition";
+
+/** Resolve one listed Sentry group through authenticated event authority. */
+async function sentryListedGroup(input, operation, issue, headers) {
+  if (typeof issue?.id !== "string" || !issue.id) {
+    refuse("sentry", operation, "issue identity authority");
+  }
+  const raw = await input.request({
+    operation,
+    url: `https://sentry.io/api/0/issues/${issue.id}/events/latest/`,
+    options: { method: "GET", headers },
+  });
+  const markers = Array.isArray(raw?.tags)
+    ? raw.tags.filter(tag => tag?.key === MARKER_TAG)
+    : [];
+  if (
+    raw?.groupID !== issue.id ||
+    markers.length !== 1 ||
+    markers[0].value !== CONDITION_MARKER
+  ) {
+    refuse("sentry", operation, "issue marker authority");
+  }
+  return { id: issue.id, marker: markers[0].value, pinned: false };
+}
+
+/** Call Linear GraphQL and reject error-bearing or unsuccessful mutations. */
+async function linearApi(input, operation, query, variables) {
+  const raw = await input.request({
+    operation,
+    url: "https://api.linear.app/graphql",
+    options: {
+      method: "POST",
+      headers: {
+        Authorization: required(input, "linear", "PROVIDER_TOKEN"),
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ query, variables }),
+    },
+  });
+  if (raw?.errors?.length || !raw?.data) {
+    refuse("linear", operation, "GraphQL error");
+  }
+  const mutation = raw.data.issueCreate ?? raw.data.issueUpdate;
+  if (mutation && mutation.success !== true) {
+    refuse("linear", operation, "success false");
+  }
+  return raw.data;
+}
+
+/** Build Linear's issue adapter over the injected JSON transport. */
+export function linearAdapter(input) {
+  const key = required(input, "linear", "LINEAR_TEAM_KEY");
+  let team;
+  const list = async (operation = "list") => {
+    const data = await linearApi(
+      input,
+      operation,
+      "query($key:String!){teams(filter:{key:{eq:$key}}){nodes{id " +
+        "states{nodes{id type}} issues(first:100){nodes{id description " +
+        "state{type}}}}}}",
+      { key }
+    );
+    const teams = data.teams?.nodes ?? [];
+    if (teams.length !== 1) {
+      refuse("linear", operation, "exact team unavailable");
+    }
+    [team] = teams;
+    return (team.issues?.nodes ?? [])
+      .filter(
+        issue =>
+          issue.description?.includes(CONDITION_MARKER) &&
+          !["completed", "canceled"].includes(issue.state?.type)
+      )
+      .map(issue => ({
+        id: issue.id,
+        marker: CONDITION_MARKER,
+        pinned: false,
+      }));
+  };
+  return linearActions(input, { list, team: () => team });
+}
+
+/** Materialize Linear's write operations around the shared readback. */
+function linearActions(input, context) {
+  const { list, team } = context;
+  const mutate = async (operation, query, variables, id, present) => {
+    await linearApi(input, operation, query, variables);
+    return readback("linear", list, id, present);
+  };
+  return {
+    async list() {
+      return list();
+    },
+    async create(draft) {
+      const data = await linearApi(
+        input,
+        "create",
+        "mutation($team:String!,$title:String!,$body:String!){issueCreate" +
+          "(input:{teamId:$team,title:$title,description:$body})" +
+          "{success issue{id}}}",
+        { team: team().id, title: draft.title, body: draft.body }
+      );
+      const id = data.issueCreate?.issue?.id;
+      if (!id) refuse("linear", "create", "missing issue identity");
+      return readback("linear", list, id, true);
+    },
+    async refresh(id, draft) {
+      return mutate(
+        "refresh",
+        "mutation($id:String!,$title:String!,$body:String!){issueUpdate" +
+          "(id:$id,input:{title:$title,description:$body})" +
+          "{success issue{id}}}",
+        { id, title: draft.title, body: draft.body },
+        id,
+        true
+      );
+    },
+    async close(id) {
+      const done = (team().states?.nodes ?? []).filter(
+        state => state.type === "completed"
+      );
+      if (done.length !== 1) {
+        refuse("linear", "close", "terminal state unavailable");
+      }
+      await mutate(
+        "close",
+        "mutation($id:String!,$state:String!){issueUpdate" +
+          "(id:$id,input:{stateId:$state}){success issue{id}}}",
+        { id, state: done[0].id },
+        id,
+        false
+      );
+    },
+  };
+}
+
+/** Build Sentry's issue adapter over the injected JSON transport. */
+export function sentryAdapter(input) {
+  const org = required(input, "sentry", "SENTRY_ORG");
+  const project = required(input, "sentry", "SENTRY_PROJECT");
+  const token = required(input, "sentry", "PROVIDER_TOKEN");
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+  };
+  const base = `https://sentry.io/api/0/projects/${org}/${project}`;
+  const list = async (operation = "list") => {
+    const marker = JSON.stringify(CONDITION_MARKER);
+    const query = `is:unresolved ${MARKER_TAG}:${marker}`;
+    const raw = await input.request({
+      operation,
+      url: `${base}/issues/?query=${encodeURIComponent(query)}` + "&limit=100",
+      options: { method: "GET", headers },
+    });
+    if (!Array.isArray(raw)) refuse("sentry", operation, "malformed response");
+    if (raw.length > 100) refuse("sentry", operation, "result overflow");
+    return await Promise.all(
+      raw.map(issue => sentryListedGroup(input, operation, issue, headers))
+    );
+  };
+  return sentryActions(input, { base, headers, list });
+}
+
+/** Resolve the public ingestion target from Sentry's authenticated key list. */
+async function sentryIngestion(input, operation, base, headers) {
+  const raw = await input.request({
+    operation,
+    url: `${base}/keys/`,
+    options: { method: "GET", headers },
+  });
+  const publicDsn = Array.isArray(raw) ? raw[0]?.dsn?.public : null;
+  let dsn;
+  try {
+    dsn = new URL(publicDsn);
+  } catch {
+    refuse("sentry", operation, "invalid public DSN");
+  }
+  const projectId = dsn.pathname.match(/^\/(\d+)$/u)?.[1];
+  if (
+    dsn.protocol !== "https:" ||
+    !dsn.username ||
+    dsn.password ||
+    !projectId ||
+    dsn.search ||
+    dsn.hash
+  ) {
+    refuse("sentry", operation, "invalid public DSN");
+  }
+  return {
+    url: `https://${dsn.host}/api/${projectId}/store/`,
+    key: decodeURIComponent(dsn.username),
+  };
+}
+
+/** Resolve one ingested event to its separately owned Sentry group. */
+async function sentryGroup(input, eventId, base, headers) {
+  const raw = await input.request({
+    operation: "readback",
+    url: `${base}/events/${eventId}/`,
+    options: { method: "GET", headers },
+  });
+  const marker = Array.isArray(raw?.tags)
+    ? raw.tags.filter(
+        tag => tag?.key === MARKER_TAG && tag.value === CONDITION_MARKER
+      )
+    : [];
+  if (
+    raw?.eventID !== eventId ||
+    typeof raw?.groupID !== "string" ||
+    !raw.groupID ||
+    raw.groupID === eventId ||
+    marker.length !== 1
+  ) {
+    refuse("sentry", "readback", "event identity or marker authority");
+  }
+  return raw.groupID;
+}
+
+/** Materialize Sentry's write operations around the shared readback. */
+function sentryActions(input, context) {
+  const { base, headers, list } = context;
+  const write = async (operation, id, draft) => {
+    const ingestion = await sentryIngestion(input, operation, base, headers);
+    const raw = await input.request({
+      operation,
+      url: ingestion.url,
+      options: {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Sentry-Auth":
+            "Sentry sentry_version=7, " + `sentry_key=${ingestion.key}`,
+        },
+        body: JSON.stringify({
+          message: draft.title,
+          fingerprint: [draft.marker],
+          level: "error",
+          tags: { [MARKER_TAG]: draft.marker },
+          extra: { body: draft.body },
+        }),
+      },
+    });
+    const eventId = raw?.id;
+    if (typeof eventId !== "string" || !eventId) {
+      refuse("sentry", operation, "missing event identity");
+    }
+    const groupId = await sentryGroup(input, eventId, base, headers);
+    if (id !== null && id !== groupId) {
+      refuse("sentry", "readback", "group identity mismatch");
+    }
+    return readback("sentry", list, groupId, true);
+  };
+  return {
+    async list() {
+      return list();
+    },
+    async create(draft) {
+      return write("create", null, draft);
+    },
+    async refresh(id, draft) {
+      return write("refresh", id, draft);
+    },
+    async close(id) {
+      await input.request({
+        operation: "close",
+        url: `https://sentry.io/api/0/issues/${id}/`,
+        options: {
+          method: "PUT",
+          headers,
+          body: '{"status":"resolved"}',
+        },
+      });
+      await readback("sentry", list, id, false);
+    },
+  };
+}

package/typescript/copy-overwrite/scripts/nightly-e2e-provider-support.mjs

@@ -0,0 +1,55 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/** Shared bounded provider transport and authority checks. */
+import { CONDITION_MARKER } from "./reconcile-nightly-e2e-tracking.mjs";
+
+/** Throw a bounded diagnostic without response or credential data. */
+export function refuse(destination, operation, status = "provider error") {
+  throw new Error(
+    `Nightly E2E ${destination} ${operation} refused: ${status}`.slice(0, 4096)
+  );
+}
+
+/** Read a required environment value without echoing it. */
+export function required(input, destination, name) {
+  const value = input.env[name];
+  if (!value?.trim()) refuse(destination, "configuration", `missing ${name}`);
+  return value;
+}
+
+/** Require an exact post-write authority snapshot. */
+export async function readback(destination, list, id, present) {
+  const records = await list("readback");
+  const exact = records.filter(record => record.id === id);
+  if (
+    present &&
+    records.length === 1 &&
+    exact.length === 1 &&
+    exact[0].marker === CONDITION_MARKER
+  ) {
+    return exact[0];
+  }
+  if (!present && exact.length === 0 && records.length === 0) return null;
+  refuse(destination, "readback", "tracker authority mismatch");
+}
+
+/** Default fetch transport used by the executable installed script. */
+export async function fetchJson(request) {
+  let response;
+  try {
+    response = await fetch(request.url, {
+      ...request.options,
+      signal: AbortSignal.timeout(30_000),
+    });
+  } catch {
+    throw new Error("provider transport error");
+  }
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  if (response.status === 204) return null;
+  try {
+    return await response.json();
+  } catch {
+    throw new Error("provider malformed response");
+  }
+}