@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/apps/page-validator.ts

@@ -42,19 +42,50 @@ export const ELEMENT_KEYS = new Set([
   "repeat",
   "watch",
 ]);
-const UI_STATE_COMPONENTS = new Set(["SearchInput", "Select", "Tabs"]);
+const UI_STATE_COMPONENTS = new Set(["SearchInput", "Select", "Tabs", "Chips"]);
 
 /**
  * Props that hold a plain action chain (an array of `{ action, params }`),
- * keyed by component type. Table's `rowActions[].actions` is nested one level
- * deeper and handled separately.
+ * keyed by component type. Chains nested one level deeper (an array prop
+ * whose items each carry a chain) are listed in `ITEM_ACTION_CHAINS`.
  */
 const PROP_ACTION_CHAINS: Record<string, readonly string[]> = {
+  Table: ["onRowClick"],
   Form: ["onSubmit"],
   Kanban: ["onMove", "onCardClick"],
   Calendar: ["onSelect"],
 };
 
+/**
+ * `[arrayProp, chainKey]` pairs: every item of `props[arrayProp]` carries an
+ * action chain under `chainKey` (Table `rowActions[].actions`, Table
+ * `columns[].onChange`, Drawer footer `actions[].actions`).
+ */
+const ITEM_ACTION_CHAINS: Record<string, readonly (readonly [string, string])[]> = {
+  Table: [
+    ["rowActions", "actions"],
+    ["columns", "onChange"],
+  ],
+  Drawer: [["actions", "actions"]],
+};
+
+/** Every `[path, chain]` nested in an element's item-chain props. */
+function itemActionChains(type: unknown, props: Record<string, unknown>, propsPath: string) {
+  const chains: { path: string; chain: unknown }[] = [];
+  for (const [arrayProp, chainKey] of ITEM_ACTION_CHAINS[String(type)] ?? []) {
+    const items = props[arrayProp];
+    if (!Array.isArray(items)) continue;
+    for (const [index, item] of items.entries()) {
+      if (!isPlainObject(item) || !Object.hasOwn(item, chainKey)) continue;
+      chains.push({
+        path: `${propsPath}.${arrayProp}.${index}.${chainKey}`,
+        chain: item[chainKey],
+      });
+    }
+  }
+  return chains;
+}
+
 /** Props naming a row field of the bound `data` query's model, per type. */
 const DATA_FIELD_PROPS: Record<string, readonly string[]> = {
   Kanban: ["columnField", "titleField", "idField"],
@@ -373,14 +404,17 @@ function actionParams(
     }
     if (op === "update" || op === "delete") {
       const rowId = params.rowId;
+      // A `$state` binding is the Drawer-footer shape: the open record's id
+      // lives at `/route/params/<param>` (both chain runners resolve it).
       const validRowId =
         typeof rowId === "string" ||
+        isStateBinding(rowId) ||
         (isPlainObject(rowId) && typeof rowId.$row === "string" && Object.keys(rowId).length === 1);
       if (!validRowId) {
         result.issues.push(
           issue(
             appendPath(paramsPath, "rowId"),
-            "is required for update and delete and must be a string or $row binding",
+            "is required for update and delete and must be a string, $row, or $state binding",
           ),
         );
       }
@@ -416,6 +450,20 @@ function actionParams(
         issue(appendPath(paramsPath, "name"), `unknown app action "${String(params.name)}"`),
       );
     }
+  } else if (step.action === "ui.toast") {
+    // The Undo chain runs through the same handlers as any other chain, so
+    // its steps get the same per-action checks (models, queries, actions).
+    const undo = toastUndoChain(step);
+    if (Array.isArray(undo)) {
+      const undoResult = validateActionChain(
+        undo,
+        appendPath(appendPath(paramsPath, "undo"), "actions"),
+        definition,
+        catalog,
+      );
+      result.issues.push(...undoResult.issues);
+      result.stateRefs.push(...undoResult.stateRefs);
+    }
   }
 
   return result;
@@ -689,10 +737,22 @@ function visitActionChain(
   const normalized = allowSingle && isPlainObject(chain) ? [chain] : chain;
   if (!Array.isArray(normalized)) return;
   for (const [index, step] of normalized.entries()) {
-    if (isPlainObject(step)) visit(step, appendPath(path, index));
+    if (!isPlainObject(step)) continue;
+    const stepPath = appendPath(path, index);
+    visit(step, stepPath);
+    // `ui.toast` nests a whole chain (the Undo button) inside its params.
+    const undo = toastUndoChain(step);
+    if (undo !== undefined) visitActionChain(undo, `${stepPath}.params.undo.actions`, visit, false);
   }
 }
 
+/** The `undo.actions` chain of a `ui.toast` step, when it has one. */
+function toastUndoChain(step: Record<string, unknown>): unknown {
+  if (step.action !== "ui.toast" || !isPlainObject(step.params)) return undefined;
+  const undo = step.params.undo;
+  return isPlainObject(undo) && Object.hasOwn(undo, "actions") ? undo.actions : undefined;
+}
+
 function visitPageActionSteps(
   page: ElementTree,
   pagePath: string,
@@ -712,16 +772,12 @@ function visitPageActionSteps(
     }
 
     if (!isPlainObject(rawElement.props)) continue;
-    if (rawElement.type === "Table" && Array.isArray(rawElement.props.rowActions)) {
-      for (const [index, rowAction] of rawElement.props.rowActions.entries()) {
-        if (!isPlainObject(rowAction)) continue;
-        visitActionChain(
-          rowAction.actions,
-          `${elementPath}.props.rowActions.${index}.actions`,
-          visit,
-          false,
-        );
-      }
+    for (const { path, chain } of itemActionChains(
+      rawElement.type,
+      rawElement.props,
+      `${elementPath}.props`,
+    )) {
+      visitActionChain(chain, path, visit, false);
     }
     for (const prop of PROP_ACTION_CHAINS[String(rawElement.type)] ?? []) {
       visitActionChain(rawElement.props[prop], `${elementPath}.props.${prop}`, visit, false);
@@ -1251,9 +1307,14 @@ export function validatePage(
 
     if (component) {
       const propsPath = appendPath(elementPath, "props");
+      const itemChainPaths = new Set(
+        isPlainObject(rawElement.props)
+          ? itemActionChains(type, rawElement.props, propsPath).map(({ path }) => path)
+          : [],
+      );
       const actionChainPath = (path: string): boolean =>
         (PROP_ACTION_CHAINS[String(type)] ?? []).some((prop) => path === `${propsPath}.${prop}`) ||
-        (type === "Table" && /^.+\.rowActions\.\d+\.actions$/.test(path));
+        itemChainPaths.has(path);
       const propsResult = validateSchema(
         Object.hasOwn(rawElement, "props") ? rawElement.props : {},
         component.props,
@@ -1334,6 +1395,15 @@ export function validatePage(
             queryModel.model,
             issues,
           );
+          for (const prop of ["onRowClick", "columns"] as const) {
+            collectRowFieldIssues(
+              rawElement.props[prop],
+              `${elementPath}.props.${prop}`,
+              queryModel.modelName,
+              queryModel.model,
+              issues,
+            );
+          }
         }
       } else if (type === "DetailList") {
         const queryModel = queryModelFromDataBinding(definition, rawElement.props.data);
@@ -1479,24 +1549,16 @@ export function validatePage(
       }
     }
 
-    if (
-      type === "Table" &&
-      isPlainObject(rawElement.props) &&
-      Array.isArray(rawElement.props.rowActions)
-    ) {
-      for (const [rowActionIndex, rowAction] of rawElement.props.rowActions.entries()) {
-        if (!isPlainObject(rowAction) || !Object.hasOwn(rowAction, "actions")) continue;
-        const chainResult = validateActionChain(
-          rowAction.actions,
-          `${elementPath}.props.rowActions.${rowActionIndex}.actions`,
-          definition,
-          catalog,
-        );
+    if (isPlainObject(rawElement.props)) {
+      for (const { path, chain } of itemActionChains(
+        type,
+        rawElement.props,
+        `${elementPath}.props`,
+      )) {
+        const chainResult = validateActionChain(chain, path, definition, catalog);
         issues.push(...chainResult.issues);
         stateRefs.push(...chainResult.stateRefs);
       }
-    }
-    if (isPlainObject(rawElement.props)) {
       for (const prop of PROP_ACTION_CHAINS[String(type)] ?? []) {
         if (!Object.hasOwn(rawElement.props, prop)) continue;
         const chainResult = validateActionChain(

package/src/azure-devops/api.ts

@@ -3,7 +3,12 @@
  * and resolving the bot identity behind the PAT. Uses raw fetch, no SDK.
  */
 
-import { getAzureDevOpsOrgUrl, getAzureDevOpsToken, normalizeOrgUrl } from "./auth";
+import {
+  getAzureDevOpsOrgUrl,
+  getAzureDevOpsToken,
+  isTrustedOrgUrl,
+  normalizeOrgUrl,
+} from "./auth";
 
 const API_VERSION = "7.1";
 
@@ -32,7 +37,55 @@ function pullRequestBase(ref: AzureDevOpsPullRequestRef): string {
   );
 }
 
-let cachedBotId: { orgUrl: string; id: string } | null = null;
+interface BotIdentity {
+  id: string | null;
+  uniqueName: string | null;
+}
+
+/** A transient failure resolving the bot identity; the caller should let the delivery be retried. */
+export class AzureDevOpsLookupError extends Error {}
+
+let cachedBotIdentity: { orgUrl: string; identity: BotIdentity } | null = null;
+
+/** Org URL to query, or null when there is none or it is not safe to send the PAT to. */
+function credentialedOrgUrl(orgBaseUrl: string | null | undefined): string | null {
+  const orgUrl = normalizeOrgUrl(orgBaseUrl) ?? getAzureDevOpsOrgUrl();
+  if (!orgUrl || !getAzureDevOpsToken()) return null;
+  if (!isTrustedOrgUrl(orgUrl)) {
+    console.error("[AzureDevOps] Refusing to send credentials to an untrusted organization URL");
+    return null;
+  }
+  return orgUrl;
+}
+
+/**
+ * `_apis/connectionData` of the identity that owns the PAT, cached per org.
+ * Throws AzureDevOpsLookupError on a failed request. Redirects are refused so
+ * the PAT never follows a response to another host.
+ */
+async function loadBotIdentity(orgUrl: string): Promise<BotIdentity> {
+  if (cachedBotIdentity?.orgUrl === orgUrl) return cachedBotIdentity.identity;
+  let data: {
+    authenticatedUser?: { id?: string; properties?: { Account?: { $value?: string } } };
+  };
+  try {
+    const resp = await fetch(`${orgUrl}/_apis/connectionData`, {
+      headers: headers(),
+      redirect: "error",
+    });
+    if (!resp.ok) throw new AzureDevOpsLookupError(`connectionData returned ${resp.status}`);
+    data = (await resp.json()) as typeof data;
+  } catch (err) {
+    if (err instanceof AzureDevOpsLookupError) throw err;
+    throw new AzureDevOpsLookupError(`connectionData request failed: ${String(err)}`);
+  }
+  const identity = {
+    id: data.authenticatedUser?.id ?? null,
+    uniqueName: data.authenticatedUser?.properties?.Account?.$value?.trim() || null,
+  };
+  if (identity.id || identity.uniqueName) cachedBotIdentity = { orgUrl, identity };
+  return identity;
+}
 
 /**
  * Identity GUID of the bot. A picker @mention is stored as `@<GUID>` in the
@@ -46,31 +99,54 @@ export async function resolveAzureDevOpsBotId(
 ): Promise<string | null> {
   const fromEnv = process.env.AZURE_DEVOPS_BOT_ID?.trim();
   if (fromEnv) return fromEnv;
+  const orgUrl = credentialedOrgUrl(orgBaseUrl);
+  if (!orgUrl) return null;
+  try {
+    return (await loadBotIdentity(orgUrl)).id;
+  } catch (err) {
+    console.error(`[AzureDevOps] Failed to resolve bot identity:`, err);
+    return null;
+  }
+}
 
-  const orgUrl = normalizeOrgUrl(orgBaseUrl) ?? getAzureDevOpsOrgUrl();
-  if (!orgUrl || !getAzureDevOpsToken()) return null;
-  if (cachedBotId?.orgUrl === orgUrl) return cachedBotId.id;
-
+/**
+ * Sign-in name (usually the email) of the identity that owns the PAT, from
+ * `_apis/connectionData` (`authenticatedUser.properties.Account.$value`),
+ * cached per org. Work-item payloads carry people as the string
+ * `"Display Name <unique@name>"` with no GUID, so this is what identifies the
+ * bot in `System.AssignedTo`. Returns null when it cannot be resolved.
+ */
+export async function resolveAzureDevOpsBotUniqueName(
+  orgBaseUrl: string | null | undefined,
+): Promise<string | null> {
+  const orgUrl = credentialedOrgUrl(orgBaseUrl);
+  if (!orgUrl) return null;
   try {
-    const resp = await fetch(`${orgUrl}/_apis/connectionData`, { headers: headers() });
-    if (!resp.ok) {
-      console.error(`[AzureDevOps] Failed to resolve bot identity: ${resp.status}`);
-      return null;
-    }
-    const data = (await resp.json()) as { authenticatedUser?: { id?: string } };
-    const id = data.authenticatedUser?.id;
-    if (!id) return null;
-    cachedBotId = { orgUrl, id };
-    return id;
+    return (await loadBotIdentity(orgUrl)).uniqueName;
   } catch (err) {
-    console.error(`[AzureDevOps] Error resolving bot identity:`, err);
+    console.error(`[AzureDevOps] Failed to resolve bot sign-in name:`, err);
     return null;
   }
 }
 
+/**
+ * Both bot identifiers in one lookup, for work-item handlers. Unlike the
+ * helpers above, a failed request throws AzureDevOpsLookupError instead of
+ * degrading to null, so a transient outage makes the delivery retryable.
+ */
+export async function resolveAzureDevOpsBotIdentity(
+  orgBaseUrl: string | null | undefined,
+): Promise<BotIdentity> {
+  const fromEnv = process.env.AZURE_DEVOPS_BOT_ID?.trim() || null;
+  const orgUrl = credentialedOrgUrl(orgBaseUrl);
+  if (!orgUrl) return { id: fromEnv, uniqueName: null };
+  const identity = await loadBotIdentity(orgUrl);
+  return { id: fromEnv ?? identity.id, uniqueName: identity.uniqueName };
+}
+
 /** Reset the cached bot identity (tests, config reloads). */
 export function resetAzureDevOpsBotIdCache(): void {
-  cachedBotId = null;
+  cachedBotIdentity = null;
 }
 
 /**

package/src/azure-devops/auth.ts

@@ -66,6 +66,38 @@ export function normalizeOrgUrl(url: string | null | undefined): string | null {
   return trimmed ? trimmed : null;
 }
 
+/**
+ * Organization identity of an Azure DevOps URL: `dev.azure.com/{org}` or the
+ * `{org}.visualstudio.com` host, lowercased. Null for anything that is not a
+ * plain HTTPS URL, so credentials are never attached to it.
+ */
+export function orgKeyOf(url: string | null | undefined): string | null {
+  if (!url) return null;
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password) return null;
+  const host = parsed.host.toLowerCase();
+  if (host !== "dev.azure.com") return host;
+  const org = parsed.pathname.split("/").find(Boolean);
+  return org ? `${host}/${org.toLowerCase()}` : null;
+}
+
+/**
+ * Whether the PAT may be sent to `url`. With a configured organization only
+ * that organization qualifies; without one, only the public Azure DevOps hosts.
+ */
+export function isTrustedOrgUrl(url: string | null | undefined): boolean {
+  const key = orgKeyOf(url);
+  if (!key) return false;
+  const configured = orgKeyOf(orgUrl);
+  if (orgUrl) return key === configured;
+  return key.startsWith("dev.azure.com/") || key.endsWith(".visualstudio.com");
+}
+
 /** Bot name for plain-text `@name` mentions. */
 export const AZURE_DEVOPS_BOT_NAME = process.env.AZURE_DEVOPS_BOT_NAME ?? "agent-swarm-bot";