powerautomate-mcp 0.5.3 → 0.7.0

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, writeFileSync, lstatSync, statSync, readFileSync, unlinkSync, chmodSync, readdirSync } from 'fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, lstatSync, statSync, unlinkSync, chmodSync, readdirSync } from 'fs';
 import { dirname, join } from 'path';
 import { platform, env } from 'process';
 import { homedir } from 'os';
@@ -381,6 +381,7 @@ Create the file with your Microsoft Entra app client ID and Power Automate envir
       err
     );
   }
+  parsed = interpolateEnvVars(parsed);
   const envClientId = env["PA_MCP_CLIENT_ID"];
   if (envClientId) {
     const UUID_RE3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -423,12 +424,34 @@ function resolveEnvironment(config, envNameOrId) {
       displayName: envConfig.displayName
     };
   }
-  return {
-    name: "unknown",
-    id: "",
-    region: "unitedstates",
-    displayName: void 0
-  };
+  {
+    throw new ConfigurationError(
+      `Environment "${envKey}" not found in configuration. Available environments: ${Object.keys(config.environments).filter((k) => k !== "default").join(", ") || "(none)"}`
+    );
+  }
+}
+function interpolateEnvVars(value) {
+  if (typeof value === "string") {
+    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
+      const envValue = env[varName];
+      if (envValue === void 0) {
+        logger.warn({ varName }, "Environment variable referenced in config is not set");
+        return "";
+      }
+      return envValue;
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map(interpolateEnvVars);
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = interpolateEnvVars(val);
+    }
+    return result;
+  }
+  return value;
 }
 
 // src/utils/security.ts
@@ -1126,12 +1149,12 @@ var FlowManagementApi = class {
       throw new ApiError(`${context}: API error`, statusCode, errorDetails);
     }
     if (!responseText) {
-      return {};
+      return { value: [] };
     }
     return JSON.parse(responseText);
   }
   /**
-   * List flows in an environment
+   * List flows in an environment with optional pagination support
    */
   async listFlows(options = {}) {
     const envId = options.environment ?? this.defaultEnvironmentId;
@@ -1154,8 +1177,8 @@ var FlowManagementApi = class {
         response,
         "List flows"
       );
-      apiLogger.info({ count: data.value.length }, "Listed flows");
-      return data.value;
+      apiLogger.info({ count: data.value.length, hasMore: !!data.nextLink }, "Listed flows");
+      return { flows: data.value, nextLink: data.nextLink };
     }, "List flows");
   }
   /**
@@ -1448,9 +1471,13 @@ var FlowManagementApi = class {
     const safeFlowId = validateRowId(flowId);
     const safeRunId = validateRowId(runId);
     apiLogger.info({ flowId: safeFlowId, runId: safeRunId, envId }, "Resubmitting flow run");
+    const flow = await this.getFlow(safeFlowId, envId);
+    const triggers = flow.properties.definition?.triggers ?? {};
+    const triggerName = Object.keys(triggers)[0] ?? "manual";
+    apiLogger.debug({ flowId: safeFlowId, triggerName }, "Using trigger name for resubmit");
     const url = this.buildUrl(
       envId,
-      `/flows/${safeFlowId}/triggers/manual/histories/${safeRunId}/resubmit`
+      `/flows/${safeFlowId}/triggers/${triggerName}/histories/${safeRunId}/resubmit`
     );
     const headers = await this.getAuthHeaders();
     return wrapApiCall(async () => {
@@ -1549,7 +1576,7 @@ var FlowManagementApi = class {
    */
   async listApprovals(environmentId, top) {
     const envId = environmentId ?? this.defaultEnvironmentId;
-    const limit = top ?? 25;
+    const limit = Math.min(top ?? 25, MAX_PAGE_SIZE);
     apiLogger.debug({ envId, limit }, "Listing approvals");
     const url = this.buildUrl(envId, "/approvals", { $top: limit });
     const headers = await this.getAuthHeaders();
@@ -1631,6 +1658,12 @@ var ConnectorMetadataApi = class {
    */
   async handleResponse(response, context) {
     const { statusCode, body } = response;
+    if (statusCode === 429) {
+      await body.text();
+      const retryAfter = response.headers["retry-after"];
+      const retryMs = retryAfter ? parseInt(String(retryAfter), 10) * 1e3 : void 0;
+      throw new RateLimitError(retryMs);
+    }
     const MAX_RESPONSE_SIZE = 50 * 1024 * 1024;
     const chunks = [];
     let totalSize = 0;
@@ -1965,6 +1998,12 @@ var GraphApi = class {
    */
   async handleBinaryResponse(response, context) {
     const { statusCode, body, headers } = response;
+    if (statusCode === 429) {
+      await body.text();
+      const retryAfter = response.headers["retry-after"];
+      const retryMs = retryAfter ? parseInt(String(retryAfter), 10) * 1e3 : void 0;
+      throw new RateLimitError(retryMs);
+    }
     if (statusCode >= 400) {
       const responseText = await body.text();
       graphLogger.error({ statusCode, context }, "Graph API binary response error");
@@ -1993,6 +2032,12 @@ var GraphApi = class {
   }
   async handleResponse(response, context) {
     const { statusCode, body } = response;
+    if (statusCode === 429) {
+      await body.text();
+      const retryAfter = response.headers["retry-after"];
+      const retryMs = retryAfter ? parseInt(String(retryAfter), 10) * 1e3 : void 0;
+      throw new RateLimitError(retryMs);
+    }
     const MAX_RESPONSE_SIZE = 50 * 1024 * 1024;
     const chunks = [];
     let totalSize = 0;
@@ -2015,7 +2060,7 @@ var GraphApi = class {
       throw new ApiError(`${context}: Graph API error`, statusCode, errorDetails);
     }
     if (!responseText) {
-      return {};
+      return { value: [] };
     }
     return JSON.parse(responseText);
   }
@@ -3262,6 +3307,12 @@ var DataverseApi = class {
    */
   async handleResponse(response, context) {
     const { statusCode, body } = response;
+    if (statusCode === 429) {
+      await body.text();
+      const retryAfter = response.headers["retry-after"];
+      const retryMs = retryAfter ? parseInt(String(retryAfter), 10) * 1e3 : void 0;
+      throw new RateLimitError(retryMs);
+    }
     const MAX_RESPONSE_SIZE = 50 * 1024 * 1024;
     const chunks = [];
     let totalSize = 0;
@@ -3287,7 +3338,7 @@ var DataverseApi = class {
       throw new ApiError(`${context}: API error`, statusCode, errorDetails);
     }
     if (!responseText) {
-      return {};
+      return { value: [] };
     }
     return JSON.parse(responseText);
   }
@@ -4080,6 +4131,7 @@ var SchemaCache = class {
 };
 var listFlowsInputSchema = z.object({
   environment: z.string().optional().describe("Environment name or GUID. Uses default if omitted."),
+  search: z.string().optional().describe("Search flows by display name (case-insensitive substring match). Applied client-side after fetching."),
   filter: z.string().optional().describe(`OData filter expression (e.g., "properties/state eq 'Started'")`),
   top: z.number().min(1).max(250).optional().describe("Maximum number of results to return (default 50, max 250)")
 });
@@ -4093,6 +4145,10 @@ var listFlowsTool = {
         type: "string",
         description: "Environment name or GUID. Uses default if omitted."
       },
+      search: {
+        type: "string",
+        description: "Search flows by display name (case-insensitive substring match)."
+      },
       filter: {
         type: "string",
         description: `OData filter expression (e.g., "properties/state eq 'Started'")`
@@ -4117,11 +4173,16 @@ async function handleListFlows(api, input) {
       return `Invalid filter: ${err instanceof Error ? err.message : "Filter contains disallowed patterns"}`;
     }
   }
-  const flows = await api.listFlows({
+  const result = await api.listFlows({
     environment: parsed.environment,
     filter: safeFilter,
     top: parsed.top ?? 50
   });
+  let flows = result.flows;
+  if (parsed.search) {
+    const needle = parsed.search.toLowerCase();
+    flows = flows.filter((f) => f.properties.displayName.toLowerCase().includes(needle));
+  }
   if (flows.length === 0) {
     return "No flows found";
   }
@@ -4131,6 +4192,10 @@ async function handleListFlows(api, input) {
     const modified = new Date(flow.properties.lastModifiedTime).toLocaleDateString();
     lines.push(`  ${state} ${flow.properties.displayName} (${flow.name}) - ${modified}`);
   }
+  if (result.nextLink) {
+    lines.push(`
+(More flows available \u2014 use skipToken for next page)`);
+  }
   return lines.join("\n");
 }
 var getFlowInputSchema = z.object({
@@ -4659,37 +4724,7 @@ function validateActions(actions, result) {
   for (const [name, action] of Object.entries(actions)) {
     validateAction(action, `actions.${name}`, actionNames, result);
   }
-  const visited = /* @__PURE__ */ new Set();
-  const visiting = /* @__PURE__ */ new Set();
-  const detectCycle = (actionName, stack = []) => {
-    if (visiting.has(actionName)) {
-      return [...stack, actionName];
-    }
-    if (visited.has(actionName)) {
-      return null;
-    }
-    visiting.add(actionName);
-    stack.push(actionName);
-    const action = actions[actionName];
-    if (action?.runAfter) {
-      for (const depName of Object.keys(action.runAfter)) {
-        if (actionNames.has(depName)) {
-          const cycle = detectCycle(depName, stack);
-          if (cycle) return cycle;
-        }
-      }
-    }
-    visiting.delete(actionName);
-    visited.add(actionName);
-    return null;
-  };
-  for (const actionName of actionNames) {
-    const cycle = detectCycle(actionName);
-    if (cycle) {
-      addError(result, "actions", `Circular dependency detected: ${cycle.join(" -> ")}`);
-      break;
-    }
-  }
+  detectCircularDependencies(actions, actionNames, "actions", result);
 }
 function validateAction(action, path, allActions, result) {
   if (!action.type) {
@@ -4761,36 +4796,70 @@ function validateConnectorAction(action, path, result) {
     addError(result, `${path}.inputs.host.operationId`, "Missing operation ID");
   }
 }
-function validateConditionAction(action, path, allActions, result) {
+function validateNestedActions(actions, path, result) {
+  const localScope = new Set(Object.keys(actions));
+  for (const [name, subAction] of Object.entries(actions)) {
+    validateAction(subAction, `${path}.${name}`, localScope, result);
+  }
+  detectCircularDependencies(actions, localScope, path, result);
+}
+function detectCircularDependencies(actions, actionNames, path, result) {
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const detectCycle = (actionName, stack = []) => {
+    if (visiting.has(actionName)) {
+      return [...stack, actionName];
+    }
+    if (visited.has(actionName)) {
+      return null;
+    }
+    visiting.add(actionName);
+    stack.push(actionName);
+    const action = actions[actionName];
+    if (action?.runAfter) {
+      for (const depName of Object.keys(action.runAfter)) {
+        if (actionNames.has(depName)) {
+          const cycle = detectCycle(depName, stack);
+          if (cycle) return cycle;
+        }
+      }
+    }
+    visiting.delete(actionName);
+    visited.add(actionName);
+    return null;
+  };
+  for (const actionName of actionNames) {
+    const cycle = detectCycle(actionName);
+    if (cycle) {
+      addError(result, path, `Circular dependency detected: ${cycle.join(" -> ")}`);
+      break;
+    }
+  }
+}
+function validateConditionAction(action, path, _allActions, result) {
   if (!action.expression) {
     addError(result, `${path}.expression`, "Condition action must have an expression");
   }
   if (!action.actions || Object.keys(action.actions).length === 0) {
     addWarning(result, `${path}.actions`, "Condition 'if true' branch has no actions");
   } else {
-    for (const [name, subAction] of Object.entries(action.actions)) {
-      validateAction(subAction, `${path}.actions.${name}`, allActions, result);
-    }
+    validateNestedActions(action.actions, `${path}.actions`, result);
   }
   if (action.else?.actions) {
-    for (const [name, subAction] of Object.entries(action.else.actions)) {
-      validateAction(subAction, `${path}.else.actions.${name}`, allActions, result);
-    }
+    validateNestedActions(action.else.actions, `${path}.else.actions`, result);
   }
 }
-function validateForeachAction(action, path, allActions, result) {
+function validateForeachAction(action, path, _allActions, result) {
   if (!action.foreach) {
     addError(result, `${path}.foreach`, "Foreach action must have a foreach expression");
   }
   if (!action.actions || Object.keys(action.actions).length === 0) {
     addWarning(result, `${path}.actions`, "Foreach loop has no actions");
   } else {
-    for (const [name, subAction] of Object.entries(action.actions)) {
-      validateAction(subAction, `${path}.actions.${name}`, allActions, result);
-    }
+    validateNestedActions(action.actions, `${path}.actions`, result);
   }
 }
-function validateSwitchAction(action, path, allActions, result) {
+function validateSwitchAction(action, path, _allActions, result) {
   if (!action.expression) {
     addError(result, `${path}.expression`, "Switch action must have an expression");
   }
@@ -4799,37 +4868,29 @@ function validateSwitchAction(action, path, allActions, result) {
   } else {
     for (const [caseName, caseData] of Object.entries(action.cases)) {
       if (caseData.actions) {
-        for (const [name, subAction] of Object.entries(caseData.actions)) {
-          validateAction(subAction, `${path}.cases.${caseName}.actions.${name}`, allActions, result);
-        }
+        validateNestedActions(caseData.actions, `${path}.cases.${caseName}.actions`, result);
       }
     }
   }
   if (action.default?.actions) {
-    for (const [name, subAction] of Object.entries(action.default.actions)) {
-      validateAction(subAction, `${path}.default.actions.${name}`, allActions, result);
-    }
+    validateNestedActions(action.default.actions, `${path}.default.actions`, result);
   }
 }
-function validateScopeAction(action, path, allActions, result) {
+function validateScopeAction(action, path, _allActions, result) {
   if (!action.actions || Object.keys(action.actions).length === 0) {
     addWarning(result, `${path}.actions`, "Scope has no actions");
   } else {
-    for (const [name, subAction] of Object.entries(action.actions)) {
-      validateAction(subAction, `${path}.actions.${name}`, allActions, result);
-    }
+    validateNestedActions(action.actions, `${path}.actions`, result);
   }
 }
-function validateUntilAction(action, path, allActions, result) {
+function validateUntilAction(action, path, _allActions, result) {
   if (!action.expression) {
     addError(result, `${path}.expression`, "Until action must have an expression");
   }
   if (!action.actions || Object.keys(action.actions).length === 0) {
     addWarning(result, `${path}.actions`, "Until loop has no actions");
   } else {
-    for (const [name, subAction] of Object.entries(action.actions)) {
-      validateAction(subAction, `${path}.actions.${name}`, allActions, result);
-    }
+    validateNestedActions(action.actions, `${path}.actions`, result);
   }
 }
 
@@ -4962,14 +5023,56 @@ var KNOWN_FUNCTIONS = /* @__PURE__ */ new Set([
   "uriQuery",
   "uriScheme"
 ]);
-var EXPRESSION_REGEX = /@\{([^}]+)\}/g;
-function extractExpressions(text) {
+function extractWrappedExpressions(text) {
   const expressions = [];
+  for (let i = 0; i < text.length - 1; i++) {
+    if (text[i] !== "@") continue;
+    if (text[i + 1] !== "{") continue;
+    if (i > 0 && text[i - 1] === "@") continue;
+    let depth = 0;
+    let inString = false;
+    let stringChar = "";
+    let end = -1;
+    for (let j = i + 2; j < text.length; j++) {
+      const char = text[j];
+      const prevChar = j > i + 2 ? text[j - 1] : "";
+      if ((char === "'" || char === '"') && prevChar !== "\\") {
+        if (!inString) {
+          inString = true;
+          stringChar = char;
+        } else if (char === stringChar) {
+          inString = false;
+        }
+        continue;
+      }
+      if (inString) continue;
+      if (char === "{") {
+        depth++;
+        continue;
+      }
+      if (char === "}") {
+        if (depth === 0) {
+          end = j;
+          break;
+        }
+        depth--;
+      }
+    }
+    if (end !== -1) {
+      expressions.push(text.slice(i + 2, end));
+      i = end;
+    }
+  }
+  return expressions;
+}
+var BARE_EXPRESSION_REGEX = /@((?:triggerBody|triggerOutputs|outputs|body|items|variables|parameters|workflow|result|actionOutputs|actionBody|trigger|actions|concat|toLower|toUpper|trim|substring|replace|split|length|contains|startsWith|endsWith|indexOf|lastIndexOf|first|last|take|skip|join|createArray|union|intersection|empty|if|and|or|not|equals|greater|greaterOrEquals|less|lessOrEquals|coalesce|int|float|string|bool|json|xml|array|add|sub|mul|div|mod|max|min|utcNow|addDays|addHours|addMinutes|addSeconds|formatDateTime|guid|base64|encodeUriComponent|decodeUriComponent)\s*\(.*\))/g;
+function extractExpressions(text) {
+  const expressions = extractWrappedExpressions(text);
   let match;
-  while ((match = EXPRESSION_REGEX.exec(text)) !== null) {
+  while ((match = BARE_EXPRESSION_REGEX.exec(text)) !== null) {
     if (match[1]) expressions.push(match[1]);
   }
-  EXPRESSION_REGEX.lastIndex = 0;
+  BARE_EXPRESSION_REGEX.lastIndex = 0;
   return expressions;
 }
 function validateExpression(expression, path) {
@@ -5255,7 +5358,7 @@ function checkBestPractices(definition) {
     const type = actionObj.type;
     if (type === "Http" || type === "ApiConnection") {
       const inputs = actionObj.inputs;
-      const retryPolicy = actionObj.retryPolicy;
+      const retryPolicy = inputs?.retryPolicy ?? actionObj.retryPolicy;
       if (!retryPolicy || retryPolicy.type === "none") {
         issues.push({
           severity: "suggestion",
@@ -5441,6 +5544,160 @@ function getAllValidationWarnings(result) {
   return warnings;
 }
 
+// src/utils/expression-escape.ts
+var logger3 = createChildLogger({ module: "expression-escape" });
+function containsExpressions(value) {
+  if (typeof value === "string") {
+    return value.includes("@{") || value.startsWith("@") && !value.startsWith("@@");
+  }
+  if (Array.isArray(value)) {
+    return value.some(containsExpressions);
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).some(containsExpressions);
+  }
+  return false;
+}
+function objectToStringExpression(obj) {
+  const jsonStr = JSON.stringify(obj);
+  const segments = [];
+  let pos = 0;
+  while (pos < jsonStr.length) {
+    const exprStart = jsonStr.indexOf("@{", pos);
+    if (exprStart === -1) {
+      segments.push("'" + escapeForConcat(jsonStr.slice(pos)) + "'");
+      break;
+    }
+    const isJsonStringValue = exprStart > 0 && jsonStr[exprStart - 1] === '"';
+    if (exprStart > pos) {
+      let literal = jsonStr.slice(pos, exprStart);
+      if (isJsonStringValue) {
+        literal = literal.slice(0, -1);
+      }
+      if (literal.length > 0) {
+        segments.push("'" + escapeForConcat(literal) + "'");
+      }
+    }
+    let depth = 0;
+    let exprEnd = -1;
+    for (let i = exprStart + 2; i < jsonStr.length; i++) {
+      if (jsonStr[i] === "{") depth++;
+      else if (jsonStr[i] === "}") {
+        if (depth === 0) {
+          exprEnd = i;
+          break;
+        }
+        depth--;
+      }
+    }
+    if (exprEnd === -1) {
+      segments.push("'" + escapeForConcat(jsonStr.slice(exprStart)) + "'");
+      break;
+    }
+    const expr = jsonStr.slice(exprStart + 2, exprEnd);
+    if (isJsonStringValue) {
+      segments.push(`'"'`);
+      segments.push(expr);
+      segments.push(`'"'`);
+    } else {
+      segments.push(expr);
+    }
+    pos = exprEnd + 1;
+    if (isJsonStringValue && pos < jsonStr.length && jsonStr[pos] === '"') {
+      pos++;
+    }
+  }
+  const filtered = segments.filter((s) => s !== "''" && s !== "");
+  if (filtered.length === 0) return jsonStr;
+  if (filtered.length === 1 && !filtered[0].startsWith("'")) {
+    return `@{${filtered[0]}}`;
+  }
+  return `@{json(concat(${filtered.join(",")}))}`;
+}
+function escapeForConcat(s) {
+  return s.replace(/'/g, "''");
+}
+function preprocessActionInputs(inputs, actionName) {
+  const processedInputs = { ...inputs };
+  if (processedInputs.body && typeof processedInputs.body === "object") {
+    const bodyStr = JSON.stringify(processedInputs.body);
+    const hasAtKeys = /"@[a-zA-Z]/.test(bodyStr);
+    if (hasAtKeys || containsExpressions(processedInputs.body)) {
+      logger3.info({ action: actionName, field: "body", hasAtKeys }, "Converting action payload object to string expression");
+      processedInputs.body = objectToStringExpression(processedInputs.body);
+    }
+  }
+  if (processedInputs.parameters && typeof processedInputs.parameters === "object" && !Array.isArray(processedInputs.parameters)) {
+    const parameters = processedInputs.parameters;
+    let changed = false;
+    const processedParameters = { ...parameters };
+    for (const [key, value] of Object.entries(parameters)) {
+      if (value && typeof value === "object" && containsExpressions(value)) {
+        logger3.info({ action: actionName, field: `parameters.${key}` }, "Converting connector parameter object to string expression");
+        processedParameters[key] = objectToStringExpression(value);
+        changed = true;
+      }
+    }
+    if (changed) {
+      processedInputs.parameters = processedParameters;
+    }
+  }
+  return processedInputs;
+}
+function preprocessFlowActions(actions) {
+  const processed = {};
+  for (const [name, action] of Object.entries(actions)) {
+    if (!action || typeof action !== "object") {
+      processed[name] = action;
+      continue;
+    }
+    const actionObj = action;
+    processed[name] = { ...actionObj };
+    const processedAction = processed[name];
+    if (actionObj.inputs && typeof actionObj.inputs === "object") {
+      processedAction.inputs = preprocessActionInputs(
+        actionObj.inputs,
+        name
+      );
+    }
+    if (actionObj.actions && typeof actionObj.actions === "object") {
+      processedAction.actions = preprocessFlowActions(
+        actionObj.actions
+      );
+    }
+    if (actionObj.else && typeof actionObj.else === "object") {
+      const elseBranch = actionObj.else;
+      if (elseBranch.actions && typeof elseBranch.actions === "object") {
+        processedAction.else = {
+          ...elseBranch,
+          actions: preprocessFlowActions(elseBranch.actions)
+        };
+      }
+    }
+    if (actionObj.cases && typeof actionObj.cases === "object") {
+      const cases = actionObj.cases;
+      const processedCases = {};
+      for (const [caseName, caseVal] of Object.entries(cases)) {
+        if (caseVal && typeof caseVal === "object") {
+          const cv = caseVal;
+          if (cv.actions && typeof cv.actions === "object") {
+            processedCases[caseName] = {
+              ...cv,
+              actions: preprocessFlowActions(cv.actions)
+            };
+          } else {
+            processedCases[caseName] = caseVal;
+          }
+        } else {
+          processedCases[caseName] = caseVal;
+        }
+      }
+      processedAction.cases = processedCases;
+    }
+  }
+  return processed;
+}
+
 // src/tools/create-flow.ts
 var triggerSchema = z.object({
   type: z.string().describe("Trigger type (e.g., 'Request', 'Recurrence', 'OpenApiConnection')"),
@@ -5452,12 +5709,12 @@ var triggerSchema = z.object({
     startTime: z.string().optional(),
     timeZone: z.string().optional()
   }).optional().describe("Recurrence settings for scheduled triggers")
-});
+}).passthrough();
 var actionSchema = z.object({
   type: z.string().describe("Action type"),
   inputs: z.unknown().optional().describe("Action inputs - can be object, string, array, or any value"),
   runAfter: z.record(z.array(z.enum(["Succeeded", "Failed", "Skipped", "TimedOut"]))).optional().describe("Dependencies")
-});
+}).passthrough();
 var connectionRefSchema = z.object({
   connectionName: z.string().describe("Connection name in the environment"),
   id: z.string().describe("Connection resource ID"),
@@ -5549,13 +5806,14 @@ var createFlowTool = {
 async function handleCreateFlow(api, input) {
   const parsed = createFlowInputSchema.parse(input);
   logger.info({ displayName: parsed.displayName }, "Executing create_flow");
+  const processedActions = preprocessFlowActions(parsed.actions);
   const definition = {
     $schema: "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
     contentVersion: "1.0.0.0",
     triggers: {
       [parsed.triggerName ?? "manual"]: parsed.trigger
     },
-    actions: parsed.actions
+    actions: processedActions
   };
   if (parsed.connectionReferences && Object.keys(parsed.connectionReferences).length > 0) {
     definition.parameters = {
@@ -5656,12 +5914,12 @@ var triggerSchema2 = z.object({
     startTime: z.string().optional(),
     timeZone: z.string().optional()
   }).optional()
-});
+}).passthrough();
 var actionSchema2 = z.object({
   type: z.string(),
   inputs: z.unknown().optional(),
   runAfter: z.record(z.array(z.enum(["Succeeded", "Failed", "Skipped", "TimedOut"]))).optional()
-});
+}).passthrough();
 var connectionRefSchema2 = z.object({
   connectionName: z.string(),
   id: z.string(),
@@ -5730,11 +5988,12 @@ async function handleUpdateFlow(api, input) {
   let newDefinition;
   if (parsed.trigger || parsed.actions) {
     const triggerName = parsed.triggerName ?? Object.keys(currentDef.triggers)[0] ?? "manual";
+    const processedActions = parsed.actions ? preprocessFlowActions(parsed.actions) : currentDef.actions;
     newDefinition = {
       $schema: currentDef.$schema,
       contentVersion: currentDef.contentVersion,
       triggers: parsed.trigger ? { [triggerName]: parsed.trigger } : currentDef.triggers,
-      actions: parsed.actions ? parsed.actions : currentDef.actions
+      actions: processedActions
     };
     if (currentDef.parameters) {
       newDefinition.parameters = currentDef.parameters;
@@ -13525,7 +13784,8 @@ function formatEnvironmentDetails(env2) {
   };
 }
 async function getEnvironmentSummary(context, environmentId) {
-  const flows = await context.api.listFlows({ environment: environmentId });
+  const result = await context.api.listFlows({ environment: environmentId });
+  const flows = result.flows;
   const flowStats = {
     total: flows.length,
     started: flows.filter((f) => f.properties.state === "Started").length,
@@ -14097,6 +14357,122 @@ function getPrompt(name, args) {
       return null;
   }
 }
+var PACKAGE_NAME = "powerautomate-mcp";
+var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var CHECK_TIMEOUT_MS = 5e3;
+function getInstalledVersion() {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 5; i++) {
+      const candidate = join(dir, "package.json");
+      if (existsSync(candidate)) {
+        const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+        if (pkg.name === PACKAGE_NAME && pkg.version) {
+          return pkg.version;
+        }
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function checkForUpdate() {
+  const currentVersion = getInstalledVersion();
+  try {
+    const { statusCode, body } = await request(REGISTRY_URL, {
+      method: "GET",
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(CHECK_TIMEOUT_MS)
+    });
+    if (statusCode !== 200) {
+      await body.text();
+      return null;
+    }
+    const data = await body.json();
+    const latestVersion = data.version;
+    if (!latestVersion) return null;
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: compareVersions(latestVersion, currentVersion) > 0
+    };
+  } catch (err) {
+    logger.debug({ err }, "Update check failed (non-fatal)");
+    return null;
+  }
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function getUpdateCommand() {
+  const npmExecPath = process.env["npm_execpath"] ?? "";
+  const npmCommand = process.env["npm_command"] ?? "";
+  if (npmExecPath.includes("npx") || npmCommand === "exec") {
+    return { cmd: "npx", args: [`${PACKAGE_NAME}@latest`] };
+  }
+  if (npmExecPath.includes("yarn")) {
+    return { cmd: "yarn", args: ["global", "add", PACKAGE_NAME] };
+  }
+  if (npmExecPath.includes("pnpm")) {
+    return { cmd: "pnpm", args: ["add", "-g", PACKAGE_NAME] };
+  }
+  return { cmd: "npm", args: ["install", "-g", PACKAGE_NAME] };
+}
+async function runSelfUpdate() {
+  const info = await checkForUpdate();
+  if (info === null) {
+    console.error("Could not reach npm registry. Check your internet connection.");
+    process.exit(1);
+  }
+  if (!info.updateAvailable) {
+    console.error(`Already up to date (v${info.currentVersion}).`);
+    process.exit(0);
+  }
+  console.error(`Updating ${PACKAGE_NAME}: v${info.currentVersion} \u2192 v${info.latestVersion}`);
+  const { cmd, args } = getUpdateCommand();
+  console.error(`Running: ${cmd} ${args.join(" ")}`);
+  return new Promise((_resolve) => {
+    const child = execFile(cmd, args, { timeout: 12e4 }, (error, stdout, stderr) => {
+      if (error) {
+        console.error(`
+Update failed: ${error.message}`);
+        if (stderr) console.error(stderr);
+        console.error(`
+You can update manually: npm install -g ${PACKAGE_NAME}`);
+        process.exit(1);
+      }
+      if (stdout) console.error(stdout.trim());
+      console.error(`
+Updated to v${info.latestVersion} successfully.`);
+      process.exit(0);
+    });
+    child.stdout?.pipe(process.stderr);
+    child.stderr?.pipe(process.stderr);
+  });
+}
+function backgroundUpdateCheck() {
+  checkForUpdate().then((info) => {
+    if (info?.updateAvailable) {
+      console.error(
+        `
+  Update available: v${info.currentVersion} \u2192 v${info.latestVersion}
+  Run: powerautomate-mcp --update
+`
+      );
+    }
+  }).catch(() => {
+  });
+}
 
 // src/server.ts
 async function createMcpServer(serverConfig) {
@@ -14176,7 +14552,7 @@ async function createMcpServer(serverConfig) {
   const server = new Server(
     {
       name: "powerautomate-mcp",
-      version: "0.5.3"
+      version: getInstalledVersion()
     },
     {
       capabilities: {
@@ -14190,8 +14566,8 @@ async function createMcpServer(serverConfig) {
     logger.debug("Listing tools");
     return { tools };
   });
-  server.setRequestHandler(CallToolRequestSchema, async (request7) => {
-    const { name, arguments: args } = request7.params;
+  server.setRequestHandler(CallToolRequestSchema, async (request8) => {
+    const { name, arguments: args } = request8.params;
     logger.info({ tool: name }, "Tool called");
     if (args && !checkObjectDepth(args, 20)) {
       return {
@@ -14219,8 +14595,8 @@ async function createMcpServer(serverConfig) {
     const resources = await listAllResources(resourceContext);
     return { resources };
   });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request7) => {
-    const { uri } = request7.params;
+  server.setRequestHandler(ReadResourceRequestSchema, async (request8) => {
+    const { uri } = request8.params;
     logger.info({ uri }, "Reading resource");
     const result = await readResource(resourceContext, uri);
     if (!result) {
@@ -14232,8 +14608,8 @@ async function createMcpServer(serverConfig) {
     logger.debug("Listing prompts");
     return { prompts };
   });
-  server.setRequestHandler(GetPromptRequestSchema, async (request7) => {
-    const { name, arguments: args } = request7.params;
+  server.setRequestHandler(GetPromptRequestSchema, async (request8) => {
+    const { name, arguments: args } = request8.params;
     logger.info({ prompt: name }, "Getting prompt");
     const result = getPrompt(name, args ?? {});
     if (!result) {
@@ -14335,8 +14711,9 @@ function checkObjectDepth(obj, maxDepth, current = 0) {
   return true;
 }
 async function createDeviceCodeAuthProvider(config, silentOnly = false) {
-  const { clientId, cachePath } = config;
-  const authority = DEFAULT_AUTHORITY;
+  const { clientId, tenantId, cachePath } = config;
+  const validatedTenantId = tenantId ? validateTenantId(tenantId) : null;
+  const authority = validatedTenantId ? `https://login.microsoftonline.com/${validatedTenantId}` : DEFAULT_AUTHORITY;
   const cachePlugin = await createPersistentCachePlugin(cachePath);
   const msalConfig = {
     auth: {
@@ -14481,7 +14858,9 @@ async function createDeviceCodeAuthProvider(config, silentOnly = false) {
 }
 async function createAuthProviderFromConfig2(clientId, tenantId, cachePath, silentOnly = false) {
   const config = {
-    clientId};
+    clientId,
+    tenantId: tenantId ?? null
+  };
   return createDeviceCodeAuthProvider(config, silentOnly);
 }
 
@@ -14737,19 +15116,25 @@ function clearTokenCache() {
   return { cleared: files.length > 0, files };
 }
 var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function readExistingClientId() {
+function readExistingAuthConfig() {
   try {
     const configPath = getConfigPath();
-    if (!existsSync(configPath)) return null;
+    if (!existsSync(configPath)) return { clientId: null, tenantId: null };
     const raw = readFileSync(configPath, "utf-8");
     const parsed = JSON.parse(raw);
-    const id = parsed?.auth?.clientId;
-    if (id && UUID_RE2.test(id)) return id;
-    return null;
+    const clientId = parsed?.auth?.clientId;
+    const tenantId = parsed?.auth?.tenantId;
+    return {
+      clientId: clientId && UUID_RE2.test(clientId) ? clientId : null,
+      tenantId: tenantId && UUID_RE2.test(tenantId) ? tenantId : null
+    };
   } catch {
-    return null;
+    return { clientId: null, tenantId: null };
   }
 }
+function readExistingClientId() {
+  return readExistingAuthConfig().clientId;
+}
 async function promptForClientId(askUser) {
   print("");
   print(`  ${c.yellow}You need a Microsoft Entra app registration for your tenant.${c.reset}`);
@@ -14840,8 +15225,9 @@ async function runSetupWizard() {
     print(`  ${c.dim}Sign in with your Microsoft work account.${c.reset}`);
     print(`  ${c.dim}A device code will be shown \u2014 follow the instructions to authenticate.${c.reset}`);
     print("");
-    const authProvider = await createAuthProviderFromConfig2(clientId, null);
-    let tenantId = null;
+    const existingAuth = readExistingAuthConfig();
+    let tenantId = existingAuth.tenantId;
+    const authProvider = await createAuthProviderFromConfig2(clientId, tenantId);
     try {
       await authProvider.getToken();
       const account = authProvider.getCurrentAccount();
@@ -14997,6 +15383,71 @@ function isSetupNeeded() {
   return !existsSync(configPath);
 }
 
+// src/cli/validate.ts
+async function runValidate() {
+  console.error("Validating Power Automate MCP configuration...\n");
+  let config;
+  try {
+    const configPath = getConfigPath();
+    console.error(`  [1/3] Config file: ${configPath}`);
+    config = loadConfig();
+    const envNames = Object.keys(config.environments).filter((k) => k !== "default");
+    console.error(`        Client ID: ${config.auth.clientId}`);
+    console.error(`        Tenant: ${config.auth.tenantId ?? "common"}`);
+    console.error(`        Environments: ${envNames.join(", ") || "(none)"}`);
+    console.error(`        Default: ${config.environments.default}`);
+    console.error("        \u2713 Config valid\n");
+  } catch (err) {
+    const msg = err instanceof ConfigurationError ? err.message : String(err);
+    console.error(`        \u2717 Config error: ${msg}
+`);
+    process.exit(1);
+  }
+  let authProvider;
+  try {
+    console.error("  [2/3] Authenticating...");
+    authProvider = await createAuthProviderFromConfig(
+      config.auth.clientId,
+      config.auth.tenantId,
+      void 0,
+      true
+      // silentOnly
+    );
+    const token = await authProvider.getToken();
+    console.error(`        Token acquired (${token.length} chars)`);
+    const account = authProvider.getCurrentAccount();
+    if (account) {
+      console.error(`        Account: ${account.username ?? account.name ?? "unknown"}`);
+    }
+    console.error("        \u2713 Auth valid\n");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`        \u2717 Auth error: ${msg}`);
+    console.error("        Run: powerautomate-mcp --setup\n");
+    process.exit(1);
+  }
+  try {
+    console.error("  [3/3] Testing API connectivity...");
+    const defaultEnv = resolveEnvironment(config);
+    const flowApi = new FlowManagementApi({
+      authProvider,
+      defaultEnvironmentId: defaultEnv.id
+    });
+    const result = await flowApi.listFlows({ environment: defaultEnv.id, top: 1 });
+    const count = result.flows.length;
+    console.error(`        Environment: ${defaultEnv.name} (${defaultEnv.id})`);
+    console.error(`        Flow API reachable (${count >= 1 ? "flows found" : "connected"})`);
+    console.error("        \u2713 Connectivity valid\n");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`        \u2717 Connectivity error: ${msg}
+`);
+    process.exit(1);
+  }
+  console.error("All checks passed. Server is ready to run.\n");
+  process.exit(0);
+}
+
 // src/index.ts
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -15008,11 +15459,27 @@ function parseArgs() {
       port = parsed;
     }
   }
+  let env2;
+  const envIdx = args.indexOf("--env");
+  if (envIdx !== -1 && args[envIdx + 1] && !args[envIdx + 1].startsWith("-")) {
+    env2 = args[envIdx + 1];
+  }
+  let config;
+  const configIdx = args.indexOf("--config");
+  if (configIdx !== -1 && args[configIdx + 1] && !args[configIdx + 1].startsWith("-")) {
+    config = args[configIdx + 1];
+  }
   return {
     setup: args.includes("--setup") || args.includes("-s"),
     help: args.includes("--help") || args.includes("-h"),
+    version: args.includes("--version") || args.includes("-v"),
+    validate: args.includes("--validate"),
+    update: args.includes("--update"),
     http: args.includes("--http"),
-    port
+    port,
+    env: env2,
+    config,
+    debug: args.includes("--debug")
   };
 }
 function getConfigPathHint() {
@@ -15026,16 +15493,23 @@ function getConfigPathHint() {
 }
 function printHelp() {
   const configPath = getConfigPathHint();
+  const version = getInstalledVersion();
   console.log(`
-Power Automate MCP Server
+Power Automate MCP Server v${version}
 
 Usage: powerautomate-mcp [options]
 
 Options:
-  --setup, -s    Run the interactive setup wizard
-  --http         Start with Streamable HTTP transport (for ChatGPT / remote clients)
-  --port <N>     Port for HTTP transport (default: 3000)
-  --help, -h     Show this help message
+  --setup, -s      Run the interactive setup wizard
+  --validate       Verify config, auth, and API connectivity then exit
+  --update         Check for updates and install the latest version
+  --version, -v    Print version and exit
+  --http           Start with Streamable HTTP transport (for ChatGPT / remote clients)
+  --port <N>       Port for HTTP transport (default: 3000)
+  --env <name>     Override the default environment (alias or GUID)
+  --config <path>  Use an alternate config file
+  --debug          Enable debug-level logging
+  --help, -h       Show this help message
 
 Environment Variables:
   PA_MCP_CLIENT_ID   Microsoft Entra app client ID (overrides config file)
@@ -15056,10 +15530,30 @@ For more information, see the README.md file.
 }
 async function main() {
   const args = parseArgs();
+  if (args.version) {
+    console.log(getInstalledVersion());
+    process.exit(0);
+  }
   if (args.help) {
     printHelp();
     process.exit(0);
   }
+  if (args.update) {
+    await runSelfUpdate();
+    return;
+  }
+  if (args.debug) {
+    logger.level = "debug";
+    logger.debug("Debug logging enabled via --debug");
+  }
+  if (args.config) {
+    process.env["PA_CONFIG_PATH"] = args.config;
+    logger.debug({ configPath: args.config }, "Using custom config path");
+  }
+  if (args.validate) {
+    await runValidate();
+    return;
+  }
   if (args.setup || isSetupNeeded()) {
     const result = await runSetupWizard();
     if (!result.success) {
@@ -15072,7 +15566,11 @@ Setup failed: ${result.error}`);
       process.exit(0);
     }
   }
-  logger.info({ platform: process.platform, nodeVersion: process.version }, "Starting Power Automate MCP");
+  logger.info(
+    { platform: process.platform, nodeVersion: process.version, version: getInstalledVersion() },
+    "Starting Power Automate MCP"
+  );
+  backgroundUpdateCheck();
   let config;
   try {
     config = loadConfig();
@@ -15089,6 +15587,10 @@ Configuration Error: ${error.message}
     }
     throw error;
   }
+  if (args.env) {
+    config.environments.default = args.env;
+    logger.info({ env: args.env }, "Default environment overridden via --env");
+  }
   try {
     const { start } = await createMcpServer({
       config,