@stackgenhq/backstage-plugin-stackgen-backend 0.3.6-beta.1

package/dist/actions/core/create_appstack_action.cjs.js

@@ -0,0 +1,953 @@
+'use strict';
+
+var pluginScaffolderNode = require('@backstage/plugin-scaffolder-node');
+var zod = require('zod');
+var apiObjects = require('../../utils/api-objects.cjs.js');
+
+const iacTypeSchema = zod.z.enum(["Helm", "Terraform"]);
+const childResourceSchema = zod.z.lazy(
+  () => zod.z.object({
+    resourceType: zod.z.string(),
+    name: zod.z.string().optional(),
+    iacType: iacTypeSchema.optional(),
+    configuration: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    tfVars: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+    resourceTemplateVersionName: zod.z.string().optional(),
+    resourcePackId: zod.z.string().optional(),
+    templateId: zod.z.string().optional(),
+    children: zod.z.array(childResourceSchema).optional()
+  })
+);
+const resourceSchema = zod.z.object({
+  resourceType: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  iacType: iacTypeSchema.optional(),
+  resourceTemplateVersionName: zod.z.string().optional(),
+  configuration: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  tfVars: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  resourcePackId: zod.z.string().optional(),
+  templateId: zod.z.string().optional(),
+  children: zod.z.array(childResourceSchema).optional(),
+  /** ModuleSelect field shape — coerced to a custom module resource. */
+  id: zod.z.string().optional(),
+  baseId: zod.z.string().optional(),
+  label: zod.z.string().optional(),
+  versionName: zod.z.string().optional(),
+  moduleName: zod.z.string().optional()
+}).superRefine((res, ctx) => {
+  const hasConfiguration = !!res.configuration;
+  const hasResourcePackId = !!res.resourcePackId;
+  const looksLikeModuleSelect = typeof res.id === "string" && res.id && !res.resourceType && !res.templateId && !res.resourcePackId;
+  if (!res.resourceType && !looksLikeModuleSelect) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "resourceType is required (or pass a ModuleSelect value with id)",
+      path: ["resourceType"]
+    });
+  }
+  if (hasConfiguration && hasResourcePackId) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "only one of 'configuration' or 'resourcePackId' should be provided, not both for a resource",
+      path: ["configuration"]
+    });
+  }
+});
+const DEFAULT_TOPOLOGY_DEPLOYMENT_TYPE = "k8s";
+const createAppstackInputSchema = zod.z.object({
+  appstack: zod.z.object({
+    name: zod.z.string().trim().optional(),
+    appstackName: zod.z.string().trim().optional(),
+    teamId: zod.z.string().trim().min(1, "appstack.teamId is required"),
+    /**
+     * Required unless `templateAppstackId` is set (provider is then read from the
+     * tenant template list `cloudProvider` or appcd `coreConfig.provider`).
+     */
+    cloudProvider: zod.z.string().trim().optional(),
+    /**
+     * When set: resolve tenant template summary (and optionally appcd AppStack
+     * `coreConfig`), create an empty AppStack, then POST iac-gen topology with
+     * `appstackRefId` to clone. Mutually exclusive with a non-empty `resources` array.
+     */
+    templateAppstackId: zod.z.string().trim().uuid().optional(),
+    resources: zod.z.array(resourceSchema).default([])
+  }).superRefine((appstack, ctx) => {
+    const name = appstack.name?.trim();
+    const appstackName = appstack.appstackName?.trim();
+    if (!name && !appstackName) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: "one of 'name' or 'appstackName' must be provided",
+        path: ["name"]
+      });
+    }
+    const templateId = appstack.templateAppstackId?.trim();
+    const cloud = appstack.cloudProvider?.trim();
+    if (!templateId && !cloud) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: "appstack.cloudProvider is required when templateAppstackId is not set",
+        path: ["cloudProvider"]
+      });
+    }
+    if (templateId && appstack.resources.length > 0) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: "templateAppstackId cannot be used together with a non-empty resources array; use either topology clone or explicit resources, not both",
+        path: ["templateAppstackId"]
+      });
+    }
+  })
+});
+const appstackOutputSchema = zod.z.object({
+  appstackId: zod.z.string(),
+  appstackName: zod.z.string(),
+  appStackURL: zod.z.string(),
+  topologyId: zod.z.string().optional()
+});
+function readIntegrationsAppstackIds(body) {
+  const appstackId = typeof body?.appstackId === "string" && body.appstackId.trim() || typeof body?.id === "string" && body.id.trim() || "";
+  const topologyId = typeof body?.uuid === "string" && body.uuid.trim() || typeof body?.topologyId === "string" && body.topologyId.trim() || appstackId || "";
+  return { appstackId, topologyId };
+}
+const DEFAULT_PROJECT_MEMBER_ROLE_ID = "00000000-0000-0000-0000-000000000002";
+function validateTeamId(teamId, allowedTeams) {
+  if (allowedTeams.length === 0) return;
+  if (teamId && !allowedTeams.includes(teamId)) {
+    throw new Error(`Team ID ${teamId} is not allowed.`);
+  }
+}
+function walkResources(resources, visit) {
+  for (const resource of resources) {
+    visit(resource);
+    if (Array.isArray(resource?.children) && resource.children.length > 0) {
+      walkResources(resource.children, visit);
+    }
+  }
+}
+function countField(resources, field) {
+  let count = 0;
+  walkResources(resources, (resource) => {
+    if (resource && resource[field] !== void 0) {
+      count += 1;
+    }
+  });
+  return count;
+}
+function countResources(resources) {
+  let count = 0;
+  walkResources(resources, () => {
+    count += 1;
+  });
+  return count;
+}
+function inferIacType(resourceType) {
+  return resourceType.toLowerCase().includes("helm") ? "Helm" : "Terraform";
+}
+function stripTrailingParenthetical(label) {
+  const isSpace = (ch) => ch.trim() === "";
+  let end = label.length;
+  while (end > 0 && isSpace(label.charAt(end - 1))) {
+    end -= 1;
+  }
+  if (end === 0 || label.charAt(end - 1) !== ")") {
+    return label.trim();
+  }
+  const close = end - 1;
+  const open = label.lastIndexOf("(", close);
+  if (open < 0 || label.slice(open + 1, close).includes(")")) {
+    return label.trim();
+  }
+  let start = open;
+  while (start > 0 && isSpace(label.charAt(start - 1))) {
+    start -= 1;
+  }
+  return `${label.slice(0, start)}${label.slice(end)}`.trim();
+}
+function normalizeIacType(iacType, resourceType) {
+  if (typeof iacType === "string") {
+    const normalized = iacType.trim().toLowerCase();
+    if (normalized === "helm") return "Helm";
+    if (normalized === "terraform") return "Terraform";
+  }
+  return inferIacType(resourceType);
+}
+function resolveResourceName(resource, path) {
+  const explicitName = typeof resource?.name === "string" ? resource.name.trim() : "";
+  if (explicitName) return explicitName;
+  const configName = typeof resource?.configuration?.name === "string" ? resource.configuration.name.trim() : "";
+  if (configName) return configName;
+  return `${resource.resourceType}-${path}`;
+}
+function legacyNormalizeResources(resources, parentPath = "") {
+  return resources.map((res, index) => {
+    const resourcePath = parentPath ? `${parentPath}-${index}` : `${index}`;
+    const looksLikeModuleSelect = res && typeof res === "object" && typeof res.id === "string" && res.id && !res.resourceType && !res.templateId && !res.resourcePackId;
+    const source = looksLikeModuleSelect ? {
+      resourceType: "vibe-coded-module",
+      iacType: "Terraform",
+      templateId: res.id,
+      name: typeof res.label === "string" && res.label.trim() ? stripTrailingParenthetical(res.label) : res.moduleName || res.id
+    } : res;
+    const { children, ...rest } = source;
+    const normalized = {
+      ...rest,
+      iacType: normalizeIacType(rest.iacType, rest.resourceType),
+      name: resolveResourceName(rest, resourcePath)
+    };
+    if (Array.isArray(children) && children.length > 0) {
+      normalized.children = legacyNormalizeResources(children, resourcePath);
+    }
+    return normalized;
+  });
+}
+function validateExpectedJsonResponse(responseText, endpoint) {
+  const trimmed = responseText.trim();
+  if (!trimmed) {
+    return;
+  }
+  const lowered = trimmed.toLowerCase();
+  if (lowered === "/login" || lowered.startsWith("<!doctype html") || lowered.startsWith("<html")) {
+    throw new Error(
+      `Received login response from ${endpoint}. Check configured base URL and API token permissions.`
+    );
+  }
+  if (!(trimmed.startsWith("{") || trimmed.startsWith("["))) {
+    throw new Error(
+      `Unexpected non-JSON success response from ${endpoint}: ${trimmed.slice(0, 120)}`
+    );
+  }
+}
+function formatRequestFailure(res) {
+  return apiObjects.formatApiFailure(res.status, res.parsed, res.text, res.requestId);
+}
+async function detailFromThrownError(error) {
+  if (error?.response) {
+    return apiObjects.formatClientErrorMessage(error);
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function cloneTopologyFromTemplateAppstack(params) {
+  const {
+    stackgenApis,
+    orgId,
+    newAppstackId,
+    templateAppstackId,
+    cloudProvider,
+    deploymentType,
+    iacType,
+    traceId,
+    logger
+  } = params;
+  const body = {
+    appstackId: newAppstackId,
+    appstackRefId: templateAppstackId,
+    cloudProvider,
+    deploymentType,
+    iacType
+  };
+  logger.info(
+    `[${traceId}] cloning topology from template appstack ${templateAppstackId} onto ${newAppstackId}`
+  );
+  const res = await apiObjects.executeApiRequest(
+    () => stackgenApis.v1TopologyApiObj.createTopology({
+      orgId,
+      newTopologyRequest: body
+    }),
+    201
+  );
+  if (!res.ok) {
+    throw new Error(
+      `Failed to clone topology from template AppStack: ${formatRequestFailure(res)}`
+    );
+  }
+  validateExpectedJsonResponse(
+    res.text,
+    "topology.createTopologyRaw"
+  );
+}
+function pickTopologyIacTypeFromTargetIac(targetIac) {
+  if (!Array.isArray(targetIac)) {
+    return void 0;
+  }
+  for (const entry of targetIac) {
+    if (entry === "Helm" || entry === "Terraform") {
+      return entry;
+    }
+    if (typeof entry === "string") {
+      const n = entry.trim();
+      if (n === "Helm" || n === "Terraform") {
+        return n;
+      }
+    }
+  }
+  return void 0;
+}
+async function fetchTemplateAppStackSummary(params) {
+  const { stackgenApis, templateUuid, traceId, logger } = params;
+  const pageSize = 100;
+  let offset = 0;
+  for (; ; ) {
+    logger.info(
+      `[${traceId}] resolving template AppStack ${templateUuid} from tenant template list`
+    );
+    const pageOffset = offset;
+    const res = await apiObjects.executeApiRequest(
+      () => stackgenApis.appStacksApiObj.getTemplateAppstacks({
+        limit: pageSize,
+        offset: pageOffset
+      })
+    );
+    if (!res.ok) {
+      throw new Error(
+        `Failed to list template AppStacks from appcd: ${formatRequestFailure(res)}`
+      );
+    }
+    validateExpectedJsonResponse(res.text, "appStacksApiObj.getTemplateAppstacks");
+    const rows = Array.isArray(res.parsed?.appstacks) ? res.parsed.appstacks : [];
+    const match = rows.find(
+      (row) => String(row?.appstackId || "").trim() === templateUuid
+    );
+    if (match) {
+      const cloudProvider = typeof match.cloudProvider === "string" ? match.cloudProvider.trim() : void 0;
+      const owner = typeof match.owner === "string" ? match.owner.trim() : void 0;
+      const name = typeof match.name === "string" ? match.name.trim() : void 0;
+      return {
+        appstackId: templateUuid,
+        owner: owner || void 0,
+        cloudProvider: cloudProvider || void 0,
+        name: name || void 0
+      };
+    }
+    if (rows.length < pageSize) {
+      return void 0;
+    }
+    offset += pageSize;
+    if (offset > 1e4) {
+      logger.warn(
+        `[${traceId}] stopped paging template-appstacks after offset ${offset} without finding ${templateUuid}`
+      );
+      return void 0;
+    }
+  }
+}
+async function fetchAppStackSnapshotForTemplateClone(params) {
+  const {
+    stackgenApis,
+    orgId,
+    templateUuid,
+    traceId,
+    logger
+  } = params;
+  logger.info(
+    `[${traceId}] loading template AppStack for clone defaults`
+  );
+  const res = await apiObjects.executeApiRequest(
+    () => stackgenApis.appStacksApiObj.getAppStack({
+      uuid: templateUuid,
+      orgId
+    })
+  );
+  if (!res.ok) {
+    logger.warn(
+      `[${traceId}] could not load AppStack ${templateUuid} via appcd GET (${formatRequestFailure(res)}); using tenant template summary / defaults for clone`
+    );
+    return void 0;
+  }
+  validateExpectedJsonResponse(res.text, "appStacksApiObj.getAppStack");
+  const cc = res.parsed?.coreConfig;
+  return {
+    provider: typeof cc?.provider === "string" ? cc.provider.trim() : void 0,
+    targetCompute: typeof cc?.targetCompute === "string" ? cc.targetCompute.trim() : void 0,
+    targetIac: cc?.targetIac
+  };
+}
+function isAlreadyMemberResponse(status, parsedBody, responseText) {
+  const lowered = `${parsedBody?.msg || ""} ${parsedBody?.message || ""} ${parsedBody?.error || ""} ${responseText || ""}`.toLowerCase();
+  if (status === 409 && (lowered.includes("already") || lowered.includes("exists"))) {
+    return true;
+  }
+  return lowered.includes("already member") || lowered.includes("already exists");
+}
+async function ensureProjectMembershipForAppstackCreate(params) {
+  const { stackgenApis, projectId, roleId, traceId, logger } = params;
+  logger.info(`[${traceId}] resolving PAT user via appcd auth`);
+  const meResponse = await apiObjects.executeApiRequest(
+    () => stackgenApis.authenticationApiObject.getMe()
+  );
+  if (!meResponse.ok) {
+    throw new Error(
+      `Failed to fetch PAT user from auth/me: ${formatRequestFailure(meResponse)}`
+    );
+  }
+  validateExpectedJsonResponse(meResponse.text, "authenticationApiObject.getMe");
+  const userId = String(meResponse.parsed?.userId || "").trim();
+  if (!userId) {
+    throw new Error(
+      "auth/me response did not include userId; cannot assign project membership for appstack creation"
+    );
+  }
+  const addUserPayload = {
+    userAssignments: [{ userId, roleId }]
+  };
+  logger.info(
+    `[${traceId}] assigning PAT user ${userId} to project ${projectId} with role ${roleId}`
+  );
+  const addUserResponse = await apiObjects.executeApiRequest(
+    () => stackgenApis.projectApiObject.assignUsersToOrg({
+      orgId: projectId,
+      assignUsersToOrgRequest: addUserPayload
+    }),
+    201
+  );
+  if (!addUserResponse.ok) {
+    if (isAlreadyMemberResponse(
+      addUserResponse.status,
+      addUserResponse.parsed,
+      addUserResponse.text
+    )) {
+      logger.info(
+        `[${traceId}] PAT user ${userId} is already assigned to project ${projectId}, continuing`
+      );
+      return {
+        userId,
+        addedToProject: false
+      };
+    }
+    throw new Error(
+      `Failed to assign PAT user to project before appstack creation: ${formatRequestFailure(addUserResponse)}`
+    );
+  }
+  validateExpectedJsonResponse(
+    addUserResponse.text,
+    "projectApiObject.assignUsersToOrg"
+  );
+  return {
+    userId,
+    addedToProject: true
+  };
+}
+function collectResourcePackResources(resources) {
+  const collected = [];
+  walkResources(resources, (resource) => {
+    if (resource?.resourcePackId) {
+      collected.push(resource);
+    }
+  });
+  return collected;
+}
+function buildAppStackUrl(baseUrl, appstackId, projectName) {
+  const cleanBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  if (!appstackId) {
+    return `${cleanBaseUrl}/appstacks`;
+  }
+  if (projectName) {
+    return `${cleanBaseUrl}/project/${encodeURIComponent(
+      projectName
+    )}/appstacks/${encodeURIComponent(appstackId)}?tabId=topology`;
+  }
+  return `${cleanBaseUrl}/appstacks/${encodeURIComponent(appstackId)}`;
+}
+async function resolveTeamNameForUrl(stackgenApis, teamId, logger, traceId) {
+  try {
+    const response = await apiObjects.executeApiRequest(
+      () => stackgenApis.integrationsTeamApiObj.listTeams({ includeAll: true })
+    );
+    if (!response.ok) {
+      logger.warn(
+        `[${traceId}] failed to resolve team name for appStack URL (status=${response.status})`
+      );
+      return void 0;
+    }
+    validateExpectedJsonResponse(response.text, "integrationsTeamApiObj.listTeams");
+    let teams = [];
+    if (Array.isArray(response.parsed)) {
+      teams = response.parsed;
+    } else if (Array.isArray(response.parsed?.items)) {
+      teams = response.parsed.items;
+    }
+    const matchedTeam = teams.find(
+      (team) => (team?.id || team?.teamId || "").trim() === teamId
+    );
+    let teamName;
+    if (matchedTeam) {
+      teamName = matchedTeam?.name?.trim() || matchedTeam?.teamName?.trim() || matchedTeam?.displayName?.trim();
+    }
+    return teamName || void 0;
+  } catch (error) {
+    logger.warn(
+      `[${traceId}] unable to resolve team name for appStack URL: ${await detailFromThrownError(error)}`
+    );
+    return void 0;
+  }
+}
+const createAppStackAction = (config, logger) => {
+  return pluginScaffolderNode.createTemplateAction({
+    id: "stackGen:createAppStack",
+    description: "Creates an AppStack in StackGen for the provided configuration",
+    schema: {
+      // Backstage parseSchemas only accepts (z) => ZodType or per-field callbacks.
+      // Raw ZodObject yields schema.input/output === undefined (Installed actions blank).
+      input: () => createAppstackInputSchema,
+      output: () => appstackOutputSchema
+    },
+    async handler(ctx) {
+      let membershipPreflightWarning;
+      const traceId = `create-appstack-${Date.now()}`;
+      try {
+        const allowedTeams = config.getOptionalString("stackGen.allowedTeams")?.split(",").map((id) => id.trim()) || [];
+        validateTeamId(ctx.input.appstack.teamId, allowedTeams);
+        const stackgenApis = apiObjects.getStackgenApiObjects(config);
+        const { appstack } = ctx.input;
+        const resolvedAppstackName = appstack.name?.trim() || appstack.appstackName?.trim() || "";
+        const incomingResources = appstack.resources ?? [];
+        const projectMemberRoleId = config.getOptionalString("stackGen.projectMemberRoleId")?.trim() || DEFAULT_PROJECT_MEMBER_ROLE_ID;
+        if (!resolvedAppstackName) {
+          ctx.logger.error(
+            `[${traceId}] Invalid appstack input: both name and appstackName are empty`
+          );
+          throw new Error("appstack name is required and cannot be empty");
+        }
+        const cleanBaseUrl = stackgenApis.baseUrl;
+        const sanitizedResources = legacyNormalizeResources(incomingResources);
+        const inputResourcePackIdCount = countField(incomingResources, "resourcePackId");
+        const outputResourcePackIdCount = countField(sanitizedResources, "resourcePackId");
+        const iacTypeCount = countField(sanitizedResources, "iacType");
+        const nameCount = countField(sanitizedResources, "name");
+        const templateIdCount = countField(sanitizedResources, "templateId");
+        const totalResourceCount = countResources(sanitizedResources);
+        const templateUuidForClone = appstack.templateAppstackId?.trim();
+        const orgScopeForAppcd = config.getOptionalString("stackGen.orgId")?.trim() || appstack.teamId;
+        let templateSummary;
+        let templateSnapshot;
+        if (templateUuidForClone) {
+          templateSummary = await fetchTemplateAppStackSummary({
+            stackgenApis,
+            templateUuid: templateUuidForClone,
+            traceId,
+            logger: ctx.logger
+          });
+          if (!templateSummary) {
+            ctx.logger.warn(
+              `[${traceId}] template AppStack ${templateUuidForClone} was not found in tenant template-appstacks; will try appcd GET with destination/org scope`
+            );
+          }
+          const orgIdForTemplateGet = templateSummary?.owner || orgScopeForAppcd;
+          templateSnapshot = await fetchAppStackSnapshotForTemplateClone({
+            stackgenApis,
+            orgId: orgIdForTemplateGet,
+            templateUuid: templateUuidForClone,
+            traceId,
+            logger: ctx.logger
+          });
+        }
+        const effectiveCloudProvider = (appstack.cloudProvider?.trim() || templateSnapshot?.provider || templateSummary?.cloudProvider || "").trim();
+        if (!effectiveCloudProvider) {
+          throw new Error(
+            templateUuidForClone ? `Could not determine cloudProvider for template AppStack ${templateUuidForClone}. Pass appstack.cloudProvider, or ensure the UUID is a tenant template (template-appstacks) with cloudProvider set.` : "appstack.cloudProvider is required when templateAppstackId is not set"
+          );
+        }
+        const deploymentTypeForTopologyClone = templateSnapshot?.targetCompute?.trim() || DEFAULT_TOPOLOGY_DEPLOYMENT_TYPE;
+        const topologyIacTypeForClone = pickTopologyIacTypeFromTargetIac(templateSnapshot?.targetIac) ?? "Terraform";
+        ctx.logger.info(
+          `[${traceId}] createAppStack input summary: ${JSON.stringify({
+            teamId: appstack.teamId,
+            cloudProviderInput: appstack.cloudProvider?.trim() || void 0,
+            effectiveCloudProvider,
+            resolvedAppstackName,
+            totalResourceCount,
+            inputResourcePackIdCount,
+            outputResourcePackIdCount,
+            iacTypeCount,
+            nameCount,
+            templateAppstackId: templateUuidForClone || void 0,
+            deploymentTypeForTopologyClone,
+            topologyIacTypeForClone,
+            appcdBaseUrl: cleanBaseUrl,
+            roleId: projectMemberRoleId
+          })}`
+        );
+        try {
+          const membershipResult = await ensureProjectMembershipForAppstackCreate({
+            stackgenApis,
+            projectId: appstack.teamId,
+            roleId: projectMemberRoleId,
+            traceId,
+            logger
+          });
+          if (membershipResult.addedToProject) {
+            logger.info(
+              `[${traceId}] PAT user ${membershipResult.userId} was added to project/team ${appstack.teamId} and remains a member`
+            );
+          }
+          logger.info(
+            `[${traceId}] verified PAT user membership for project/team ${appstack.teamId} before appstack creation`
+          );
+        } catch (membershipError) {
+          membershipPreflightWarning = String(membershipError);
+          logger.warn(
+            `[${traceId}] membership preflight failed, proceeding with appstack creation: ${membershipPreflightWarning}`
+          );
+        }
+        const hasResourcePackInput = inputResourcePackIdCount > 0;
+        const hasCustomModuleInput = templateIdCount > 0;
+        if (hasResourcePackInput || hasCustomModuleInput) {
+          const blankCreateUrl = `${cleanBaseUrl}/integrations/api/v1/projects/${appstack.teamId}/appstacks`;
+          const blankCreatePayload = {
+            name: resolvedAppstackName,
+            cloudProvider: effectiveCloudProvider,
+            topology: {
+              source: { name: "backstage" },
+              resources: [],
+              resourceConnections: []
+            }
+          };
+          logger.info(
+            `[${traceId}] two-step topology flow enabled (resourcePacks=${inputResourcePackIdCount}, customModules=${templateIdCount}), creating blank appStack at ${blankCreateUrl}`
+          );
+          const blankCreateResponse = await apiObjects.executeApiRequest(
+            () => stackgenApis.integrationsAppstackApiObj.createProjectAppStack({
+              projectId: appstack.teamId,
+              appStackRequest: blankCreatePayload
+            }),
+            201
+          );
+          const blankCreateBody = blankCreateResponse.parsed;
+          const blankCreateText = blankCreateResponse.text;
+          if (!blankCreateResponse.ok) {
+            const errorMessage = formatRequestFailure(blankCreateResponse);
+            const isLikelyExistsError = blankCreateResponse.status === 409 || blankCreateResponse.status === 400;
+            if (isLikelyExistsError) {
+              try {
+                const listResponse = await apiObjects.executeApiRequest(
+                  () => stackgenApis.integrationsAppstackApiObj.listProjectAppStacks({
+                    projectId: appstack.teamId,
+                    name: resolvedAppstackName
+                  })
+                );
+                if (listResponse.ok) {
+                  const listBody = listResponse.parsed;
+                  ctx.logger.info(`[${traceId}] Existing AppStack lookup response body: ${JSON.stringify(listBody)}`);
+                  let appstacks = [];
+                  if (Array.isArray(listBody)) {
+                    appstacks = listBody;
+                  } else if (Array.isArray(listBody?.items)) {
+                    appstacks = listBody.items;
+                  }
+                  ctx.logger.info(`[${traceId}] Found ${appstacks.length} items in appstack list`);
+                  const exactMatch = appstacks.find((candidate) => {
+                    const candidateName = (candidate?.appstackName || candidate?.name || "").trim();
+                    const match = candidateName === resolvedAppstackName;
+                    if (!match) {
+                      ctx.logger.info(`[${traceId}] candidate '${candidateName}' != '${resolvedAppstackName}'`);
+                    }
+                    return match;
+                  });
+                  if (exactMatch) {
+                    ctx.logger.info(`[${traceId}] Found exact match for existing appstack: ${exactMatch.appstackId}`);
+                    const existingAppstackId = exactMatch.appstackId || exactMatch.id;
+                    const teamNameForUrl3 = await resolveTeamNameForUrl(
+                      stackgenApis,
+                      appstack.teamId,
+                      logger,
+                      traceId
+                    );
+                    const appStackUrl = buildAppStackUrl(
+                      cleanBaseUrl,
+                      existingAppstackId,
+                      teamNameForUrl3
+                    );
+                    throw new Error(
+                      `AppStack '${resolvedAppstackName}' already exists. View it here: ${appStackUrl}`
+                    );
+                  } else {
+                    ctx.logger.warn(`[${traceId}] No exact match found for '${resolvedAppstackName}' in ${appstacks.length} items`);
+                  }
+                } else {
+                  ctx.logger.warn(`[${traceId}] List appstacks failed with status ${listResponse.status}`);
+                }
+              } catch (resolveError) {
+                const errorString = String(resolveError);
+                if (errorString.includes("already exists. View it here")) {
+                  throw resolveError;
+                }
+                const resolveDetail = await detailFromThrownError(resolveError);
+                ctx.logger.warn(
+                  `[${traceId}] failed to resolve existing appstack for error message: ${resolveDetail}`
+                );
+              }
+            }
+            let membershipHint = "";
+            if (blankCreateResponse.status === 500 && String(blankCreateBody?.errCode || "").toUpperCase() === "CREATE_APPSTACK_ERROR") {
+              const visibleTeamName = await resolveTeamNameForUrl(
+                stackgenApis,
+                appstack.teamId,
+                logger,
+                traceId
+              );
+              if (!visibleTeamName) {
+                membershipHint = " The provided team/project is not visible to this PAT. Ensure the PAT user is added to the project/team before creating appstacks in it.";
+              }
+            }
+            throw new Error(
+              `Failed to create blank appstack: ${errorMessage}.${membershipHint}`
+            );
+          } else {
+            validateExpectedJsonResponse(blankCreateText, blankCreateUrl);
+          }
+          const fromBlank = readIntegrationsAppstackIds(blankCreateBody);
+          let resolvedAppstackId = fromBlank.appstackId;
+          let resolvedTopologyId = fromBlank.topologyId;
+          if (!resolvedAppstackId) {
+            const listUrl = `${cleanBaseUrl}/integrations/api/v1/projects/${appstack.teamId}/appstacks?name=${encodeURIComponent(
+              resolvedAppstackName
+            )}`;
+            logger.info(
+              `[${traceId}] resolving appstack ID by list API ${listUrl}`
+            );
+            const listResponse = await apiObjects.executeApiRequest(
+              () => stackgenApis.integrationsAppstackApiObj.listProjectAppStacks({
+                projectId: appstack.teamId,
+                name: resolvedAppstackName
+              })
+            );
+            const listBody = listResponse.parsed;
+            const listText = listResponse.text;
+            if (!listResponse.ok) {
+              throw new Error(
+                `Failed to resolve appstack ID: ${formatRequestFailure(listResponse)}`
+              );
+            }
+            validateExpectedJsonResponse(listText, listUrl);
+            let appstacks = [];
+            if (Array.isArray(listBody)) {
+              appstacks = listBody;
+            } else if (Array.isArray(listBody?.items)) {
+              appstacks = listBody.items;
+            }
+            const exactMatch = appstacks.find((candidate) => {
+              const candidateName = (candidate?.appstackName || candidate?.name || "").trim();
+              return candidateName === resolvedAppstackName;
+            });
+            const fromList = readIntegrationsAppstackIds(exactMatch);
+            resolvedAppstackId = fromList.appstackId;
+            resolvedTopologyId = fromList.topologyId || resolvedTopologyId;
+          }
+          if (!resolvedAppstackId) {
+            throw new Error(
+              `Failed to resolve appstack ID for '${resolvedAppstackName}' after blank create`
+            );
+          }
+          if (!resolvedTopologyId) {
+            resolvedTopologyId = resolvedAppstackId;
+          }
+          const resourcePackResources = collectResourcePackResources(
+            sanitizedResources
+          );
+          if (resourcePackResources.length === 0 && hasResourcePackInput) {
+            throw new Error(
+              "resource pack flow was selected but no resourcePackId was found after normalization"
+            );
+          }
+          const orgScope = config.getOptionalString("stackGen.orgId")?.trim() || appstack.teamId;
+          for (const resource of resourcePackResources) {
+            const createResourceUrl = `${cleanBaseUrl}/iac-gen/v1/topologies/${encodeURIComponent(
+              resolvedTopologyId
+            )}/resources${orgScope ? `?orgId=${encodeURIComponent(orgScope)}` : ""}`;
+            const createResourcePayload = {
+              resourceType: resource.resourceType || "resourcePack",
+              name: resource.name,
+              iacType: resource.iacType || "Terraform",
+              resourcePackId: resource.resourcePackId
+            };
+            logger.info(
+              `[${traceId}] adding resource pack to topology ${resolvedTopologyId} via ${createResourceUrl}`
+            );
+            const createResourceResponse = await apiObjects.executeApiRequest(
+              () => stackgenApis.v1ResourceApiObj.createResource({
+                topologyId: resolvedTopologyId,
+                orgId: orgScope || void 0,
+                topologyResource: createResourcePayload
+              }),
+              201
+            );
+            const createResourceText = createResourceResponse.text;
+            if (!createResourceResponse.ok) {
+              throw new Error(
+                `Failed to add resource pack to topology: ${formatRequestFailure(createResourceResponse)}`
+              );
+            }
+            validateExpectedJsonResponse(createResourceText, createResourceUrl);
+          }
+          const nonPackResources = sanitizedResources.filter(
+            (r) => !r.resourcePackId
+          );
+          for (const resource of nonPackResources) {
+            const addResourceUrl = `${cleanBaseUrl}/iac-gen/v1/topologies/${encodeURIComponent(
+              resolvedTopologyId
+            )}/resources${orgScope ? `?orgId=${encodeURIComponent(orgScope)}` : ""}`;
+            const addResourcePayload = {
+              resourceType: resource.resourceType,
+              name: resource.name,
+              iacType: resource.iacType || "Terraform"
+            };
+            if (resource.templateId) {
+              addResourcePayload.templateId = resource.templateId;
+            }
+            if (resource.configuration) {
+              addResourcePayload.configuration = resource.configuration;
+            }
+            logger.info(
+              `[${traceId}] adding non-pack resource '${resource.resourceType}' (name=${resource.name}) to topology ${resolvedTopologyId}`
+            );
+            const addResourceResponse = await apiObjects.executeApiRequest(
+              () => stackgenApis.v1ResourceApiObj.createResource({
+                topologyId: resolvedTopologyId,
+                orgId: orgScope || void 0,
+                topologyResource: addResourcePayload
+              }),
+              201
+            );
+            const addResourceText = addResourceResponse.text;
+            if (!addResourceResponse.ok) {
+              throw new Error(
+                `Failed to add resource '${resource.resourceType}' to topology: ${formatRequestFailure(addResourceResponse)}`
+              );
+            }
+            validateExpectedJsonResponse(addResourceText, addResourceUrl);
+          }
+          ctx.logger.info(
+            `[${traceId}] AppStack created successfully via resource pack flow: ${JSON.stringify({
+              appstackId: resolvedAppstackId,
+              topologyId: resolvedTopologyId,
+              appstackName: resolvedAppstackName,
+              resourcePackCount: resourcePackResources.length,
+              nonPackResourceCount: nonPackResources.length
+            })}`
+          );
+          ctx.output("appstackId", resolvedAppstackId);
+          ctx.output("appstackName", resolvedAppstackName);
+          ctx.output("topologyId", resolvedTopologyId);
+          const teamNameForUrl2 = await resolveTeamNameForUrl(
+            stackgenApis,
+            appstack.teamId,
+            logger,
+            traceId
+          );
+          ctx.output(
+            "appStackURL",
+            buildAppStackUrl(cleanBaseUrl, resolvedAppstackId, teamNameForUrl2)
+          );
+          return;
+        }
+        const apiPayload = {
+          name: resolvedAppstackName,
+          cloudProvider: effectiveCloudProvider,
+          topology: {
+            source: { name: "backstage" },
+            resources: sanitizedResources,
+            resourceConnections: []
+          }
+        };
+        const requestUrl = `${cleanBaseUrl}/integrations/api/v1/projects/${encodeURIComponent(appstack.teamId)}/appstacks`;
+        logger.info(
+          `[${traceId}] sending request to create appStack at ${requestUrl}`
+        );
+        logger.info(
+          `[${traceId}] appstack request payload summary: ${JSON.stringify({
+            name: apiPayload.name,
+            cloudProvider: apiPayload.cloudProvider,
+            resourceCount: sanitizedResources.length
+          })}`
+        );
+        const response = await apiObjects.executeApiRequest(
+          () => stackgenApis.integrationsAppstackApiObj.createProjectAppStack({
+            projectId: appstack.teamId,
+            appStackRequest: apiPayload
+          }),
+          201
+        );
+        const responseBody = response.parsed;
+        const responseText = response.text;
+        ctx.logger.info(`[${traceId}] Response status: ${response.status}`);
+        if (!response.ok) {
+          const errorMessage = formatRequestFailure(response);
+          ctx.logger.error(
+            `[${traceId}] Error response: ${errorMessage}. Diagnostics: ${JSON.stringify({
+              teamId: appstack.teamId,
+              appstackName: resolvedAppstackName,
+              cloudProvider: effectiveCloudProvider,
+              totalResourceCount,
+              inputResourcePackIdCount,
+              outputResourcePackIdCount,
+              iacTypeCount,
+              nameCount
+            })}`
+          );
+          throw new Error(
+            `Failed to create appstack: ${errorMessage}`
+          );
+        }
+        validateExpectedJsonResponse(responseText, requestUrl);
+        const createdIds = readIntegrationsAppstackIds(responseBody);
+        if (templateUuidForClone) {
+          await cloneTopologyFromTemplateAppstack({
+            stackgenApis,
+            orgId: orgScopeForAppcd,
+            newAppstackId: createdIds.appstackId,
+            templateAppstackId: templateUuidForClone,
+            cloudProvider: effectiveCloudProvider,
+            deploymentType: deploymentTypeForTopologyClone,
+            iacType: topologyIacTypeForClone,
+            traceId,
+            logger: ctx.logger
+          });
+        }
+        ctx.logger.info(
+          `[${traceId}] AppStack created successfully: ${JSON.stringify({
+            appstackId: createdIds.appstackId,
+            topologyId: createdIds.topologyId,
+            appstackName: responseBody.appstackName || resolvedAppstackName,
+            clonedFromTemplate: Boolean(templateUuidForClone)
+          })}`
+        );
+        ctx.output("appstackId", createdIds.appstackId);
+        ctx.output(
+          "appstackName",
+          responseBody.appstackName || resolvedAppstackName
+        );
+        ctx.output("topologyId", createdIds.topologyId);
+        const teamNameForUrl = await resolveTeamNameForUrl(
+          stackgenApis,
+          appstack.teamId,
+          logger,
+          traceId
+        );
+        ctx.output(
+          "appStackURL",
+          buildAppStackUrl(
+            cleanBaseUrl,
+            createdIds.appstackId,
+            teamNameForUrl
+          )
+        );
+      } catch (error) {
+        const errorString = await detailFromThrownError(error);
+        let errorMessage = `Failed to create appStack: ${errorString}`;
+        if (membershipPreflightWarning && !errorString.includes("already exists. View it here")) {
+          errorMessage += ` (membership preflight warning: ${membershipPreflightWarning})`;
+        }
+        ctx.logger.error(errorMessage);
+        throw new Error(errorMessage);
+      }
+    }
+  });
+};
+
+exports.appstackOutputSchema = appstackOutputSchema;
+exports.createAppStackAction = createAppStackAction;
+exports.createAppstackInputSchema = createAppstackInputSchema;
+//# sourceMappingURL=create_appstack_action.cjs.js.map