npm - @coreplane/switchboard - Versions diffs - 1.239.0 → 1.241.0 - Mend

@coreplane/switchboard 1.239.0 → 1.241.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (156) hide show

package/dist/assets/src/core/coordinator/driver.ts CHANGED Viewed

@@ -46,6 +46,9 @@ import {
   type ChildFacts,
   type MergeReadyFacts,
   type CoordinatorAction,
+  isAddressSeverity,
+  type AddressSeverity,
+  type AddressSeveritySource,
   type PlanGraph,
   type PlanUnitNode,
   type ShipCaps,
@@ -54,7 +57,7 @@ import {
   type UnitPipelineInput,
   type UnitPipelineState,
 } from "../ship/coordinator.js";
-import { isCoordinatorUnit, runFinishedEventType, type CoordinatorUnit } from "./contract.js";
+import { checksSettledEventType, isCoordinatorUnit, runFinishedEventType, type CoordinatorUnit } from "./contract.js";
 const MIN = 60_000;
@@ -159,6 +162,9 @@ interface PlanFacts {
   planId?: string;
   /** Who merges, as the instance's field has it: the plan route answers it, `person` when absent. */
   merge: "runner" | "person";
+  /** The severity to address, beside `merge`: the level an approve's findings are held to, and which layer set it. */
+  addressSeverity: AddressSeverity;
+  addressSeveritySource: AddressSeveritySource;
   /** The instance's mark as the plan route answers it: a generated one-unit plan (a `plan` with no `path`). */
   generated: boolean;
   repo: string;
@@ -189,6 +195,11 @@ function readPlan(a: BotAnswer): PlanFacts {
   return {
     ...(typeof b.planId === "string" ? { planId: b.planId } : {}),
     merge: b.merge === "runner" ? "runner" : "person",
+    addressSeverity: isAddressSeverity(b.addressSeverity) ? b.addressSeverity : "minor",
+    addressSeveritySource:
+      b.addressSeveritySource === "run" || b.addressSeveritySource === "user" || b.addressSeveritySource === "channel"
+        ? b.addressSeveritySource
+        : "org",
     generated: b.generated === true,
     repo: b.repo,
     base: b.base,
@@ -418,6 +429,22 @@ async function perform(
     case "sleep":
       await step.sleep(action.step, action.ms);
       return { type: "sleep", step: action.step };
+    case "wait-checks": {
+      // The intake's checks-settled event at the approved head (http-ingress.md
+      // item 12), with the machine's bounded timeout as the fallback: either
+      // way the machine re-asks the merge door, which is the guard.
+      let outcome: "event" | "timeout";
+      try {
+        await step.waitForEvent(action.step, {
+          type: checksSettledEventType(action.headSha),
+          timeout: action.timeoutMs,
+        });
+        outcome = "event";
+      } catch {
+        outcome = "timeout";
+      }
+      return { type: "wait-checks", step: action.step, outcome };
+    }
     case "merge":
       return mergeReturn(
         action.step,
@@ -465,6 +492,8 @@ async function runUnit(
       // seeded plan and `person` on a task, and the door re-checks it — the
       // branch's name never decides.
       merge: plan.merge,
+      addressSeverity: plan.addressSeverity,
+      addressSeveritySource: plan.addressSeveritySource,
       generated: plan.generated,
       ...(resume !== undefined ? { resume } : {}),
       ...(lastPush !== undefined ? { lastPush } : {}),

package/dist/assets/src/core/coordinator/instancesRoute.ts CHANGED Viewed

@@ -131,6 +131,78 @@ export function parseInstanceStatusPath(pathname: string): string | undefined {
   return INSTANCE_ID_PATTERN.test(id) ? id : undefined;
 }
+/** `POST /admin/coordinator/instances/<id>/events` — the shim's event relay
+ *  (docs/reference/specs/http-ingress.md item 12): the bot holds no Workflow
+ *  binding, so the check-run intake sends `checks-settled-<head>` through this
+ *  route and the shim's own `SHIP_COORDINATOR.get(id).sendEvent` delivers it. */
+export const COORDINATOR_INSTANCE_EVENTS_SUFFIX = "/events";
+/** The instance id an event path names, or undefined for any other path. */
+export function parseInstanceEventPath(pathname: string): string | undefined {
+  if (!pathname.startsWith(COORDINATOR_INSTANCE_STATUS_PREFIX)) return undefined;
+  if (!pathname.endsWith(COORDINATOR_INSTANCE_EVENTS_SUFFIX)) return undefined;
+  const id = pathname.slice(
+    COORDINATOR_INSTANCE_STATUS_PREFIX.length,
+    pathname.length - COORDINATOR_INSTANCE_EVENTS_SUFFIX.length,
+  );
+  return INSTANCE_ID_PATTERN.test(id) ? id : undefined;
+}
+export type ParsedSendEvent = { ok: true; type: string; payload: unknown } | { ok: false; reason: string };
+/** The Workflow event alphabet — what the engine's `sendEvent` accepts as a type. */
+const EVENT_TYPE_PATTERN = /^[A-Za-z0-9_-]{1,100}$/;
+/** The body: `{ type, payload? }` — the typed event the instance's `waitForEvent` waits on. */
+export function parseSendEventRequest(text: string): ParsedSendEvent {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { ok: false, reason: "body is not valid JSON" };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return { ok: false, reason: "body must be a JSON object" };
+  const b = parsed as Record<string, unknown>;
+  if (typeof b.type !== "string" || !EVENT_TYPE_PATTERN.test(b.type))
+    return { ok: false, reason: "`type` must be a Workflow event type: letters, digits, `_` and `-`, at most 100" };
+  return { ok: true, type: b.type, payload: b.payload };
+}
+/** How the send ended on the shim: delivered, no such instance (the engine's
+ *  own `instance.not_found`), or the engine refusing by reason (an instance
+ *  that already ended is a refusal, not an absence). */
+export type SendEventOutcome =
+  { kind: "sent"; id: string } | { kind: "absent"; id: string } | { kind: "failed"; id: string; reason: string };
+export function sendEventResponse(outcome: SendEventOutcome): { status: number; body: Record<string, unknown> } {
+  switch (outcome.kind) {
+    case "sent":
+      return { status: 200, body: { ok: true, id: outcome.id, sent: true } };
+    case "absent":
+      return { status: 404, body: { ok: false, error: "no_instance", id: outcome.id } };
+    case "failed":
+      return { status: 502, body: { ok: false, error: "send_failed", id: outcome.id, message: outcome.reason } };
+  }
+}
+/** The send answer as the bot reads it back: sent, absent, or unanswered by reason. */
+export type SendEventAnswer = { kind: "sent" } | { kind: "absent" } | { kind: "unanswered"; reason: string };
+export function readSendEventAnswer(status: number, text: string): SendEventAnswer {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = undefined;
+  }
+  const body = typeof parsed === "object" && parsed !== null ? (parsed as Record<string, unknown>) : undefined;
+  if (status === 200 && body?.ok === true && body.sent === true) return { kind: "sent" };
+  if (status === 404 && body?.error === "no_instance") return { kind: "absent" };
+  const detail = typeof body?.error === "string" ? body.error : text.slice(0, 200);
+  return { kind: "unanswered", reason: `HTTP ${status} — ${detail}` };
+}
 /** How the status read ended on the shim: the platform's status word, no such
  *  instance, or the engine failing by reason. */
 export type InstanceStatusOutcome =