@mgsoftwarebv/mg-dashboard-mcp 7.0.4 → 7.0.6

package/dist/index.js

@@ -677,10 +677,10 @@ var TRIGGER_TOOL_MODULE_MAP = {
   "trigger-run": "ci_cd"
 };
 async function discoverInstance(projectSlug, conn, proxy, sshExec2) {
-  const sql27 = `SELECT re.\\"apiKey\\" FROM \\"RuntimeEnvironment\\" re JOIN \\"Project\\" p ON re.\\"projectId\\" = p.id WHERE p.slug='${projectSlug}' AND re.slug='prod' LIMIT 1`;
+  const sql28 = `SELECT re.\\"apiKey\\" FROM \\"RuntimeEnvironment\\" re JOIN \\"Project\\" p ON re.\\"projectId\\" = p.id WHERE p.slug='${projectSlug}' AND re.slug='prod' LIMIT 1`;
   const cmd = [
     `PORT=$(docker port "${WA_CONTAINER}" 3000/tcp 2>/dev/null | head -1 | sed 's/.*://')`,
-    `KEY=$(docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql27}" 2>/dev/null | tr -d '[:space:]')`,
+    `KEY=$(docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql28}" 2>/dev/null | tr -d '[:space:]')`,
     'echo "$PORT|$KEY"'
   ].join(" && ");
   const result = await sshExec2(conn, cmd, proxy);
@@ -701,8 +701,8 @@ async function discoverInstance(projectSlug, conn, proxy, sshExec2) {
   return { port, apiKey: apiKey2 };
 }
 async function fetchRunLogs(runId, conn, proxy, sshExec2) {
-  const sql27 = `SELECT level, message, \\"isError\\", \\"createdAt\\" FROM \\"TaskEvent\\" WHERE \\"runId\\" = '${runId}' AND level IN ('INFO','WARN','ERROR','DEBUG','LOG','TRACE') ORDER BY \\"startTime\\" ASC LIMIT 200`;
-  const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql27}" 2>/dev/null`;
+  const sql28 = `SELECT level, message, \\"isError\\", \\"createdAt\\" FROM \\"TaskEvent\\" WHERE \\"runId\\" = '${runId}' AND level IN ('INFO','WARN','ERROR','DEBUG','LOG','TRACE') ORDER BY \\"startTime\\" ASC LIMIT 200`;
+  const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql28}" 2>/dev/null`;
   const result = await sshExec2(conn, cmd, proxy);
   const output = result.stdout.trim();
   if (!output) return "";
@@ -784,8 +784,8 @@ async function handleTriggerTool(name, args2, deps) {
   switch (name) {
     // -----------------------------------------------------------------
     case "trigger-list": {
-      const sql27 = 'SELECT slug, name FROM \\"Project\\" ORDER BY name';
-      const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql27}" 2>/dev/null`;
+      const sql28 = 'SELECT slug, name FROM \\"Project\\" ORDER BY name';
+      const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql28}" 2>/dev/null`;
       const result = await sshExec2(conn, cmd, proxy);
       const output = result.stdout.trim();
       if (!output) {
@@ -1024,6 +1024,39 @@ async function getMgBoilerGitHubToken() {
     return { token: null, error: "Failed to decrypt GitHub token" };
   }
 }
+async function getGitHubTokenById(id) {
+  try {
+    const rows = await getDb().execute(sql`
+      SELECT id, label, owner, notes, token_encrypted, created_at, updated_at
+      FROM github_token
+      WHERE id = ${id}
+      LIMIT 1
+    `);
+    const row = rows[0];
+    if (!row)
+      return { token: null, owner: null, error: null };
+    return {
+      token: decrypt(row.token_encrypted),
+      owner: row.owner ?? null,
+      error: null
+    };
+  } catch (error) {
+    console.error("[getGitHubTokenById] error:", error);
+    return { token: null, owner: null, error: "Failed to decrypt GitHub token" };
+  }
+}
+async function resolveReleaseGitHubToken(githubTokenId) {
+  if (githubTokenId) {
+    const { token, error } = await getGitHubTokenById(githubTokenId);
+    if (token)
+      return { token, error: null };
+    return {
+      token: null,
+      error: error || "Configured GitHub token not found"
+    };
+  }
+  return getMgBoilerGitHubToken();
+}
 
 // ../../node_modules/zod/dist/esm/v3/external.js
 var external_exports = {};
@@ -5061,7 +5094,7 @@ var coerce = {
 var NEVER = INVALID;
 
 // ../platform/dist/utils/litespeed-vhost.js
-var LITESPEED_STANDARD_APP_PATH = /^apps\/(backoffice|portal|web|api)(\/[\w-]+)?$/;
+var LITESPEED_STANDARD_APP_PATH = /^(\.|apps\/(backoffice|portal|web|api)(\/[\w-]+)?)$/;
 var LitespeedVhostMappingSchema = external_exports.object({
   domain: external_exports.string().min(1).transform((value) => normalizeVhostDomain(value)),
   appPath: external_exports.string().min(1).regex(LITESPEED_STANDARD_APP_PATH, "Unsupported appPath")
@@ -5473,7 +5506,9 @@ async function createReleaseForStage(userId, params) {
       "BAD_REQUEST"
     );
   }
-  const { token } = await getMgBoilerGitHubToken();
+  const { token } = await resolveReleaseGitHubToken(
+    profile.github_token_id ?? null
+  );
   if (!token) {
     throw new CreateReleaseError(
       "GitHub token is not configured",
@@ -5612,6 +5647,449 @@ async function createReleaseForStage(userId, params) {
     authorName: triggerAuthorName
   };
 }
+var GITHUB_API3 = "https://api.github.com";
+var ReleaseProfileQuickCreateError = class extends Error {
+  constructor(message, code = "INTERNAL_SERVER_ERROR") {
+    super(message);
+    this.code = code;
+    this.name = "ReleaseProfileQuickCreateError";
+  }
+};
+function inferDeployMethod(folderName, hasNextConfig, hasDockerfile, hasPm2Ecosystem) {
+  if (hasPm2Ecosystem && hasNextConfig) return "pm2";
+  if (hasPm2Ecosystem && !hasDockerfile && !folderName.toLowerCase().includes("api"))
+    return "pm2";
+  if (hasNextConfig) return "pm2";
+  if (hasDockerfile || folderName.toLowerCase().includes("api"))
+    return "docker";
+  return "none";
+}
+function toLabel(folderName) {
+  return folderName.charAt(0).toUpperCase() + folderName.slice(1);
+}
+async function scanRepoForApps(repoFullName, githubToken, ref = "main") {
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    Authorization: `Bearer ${githubToken}`,
+    "Content-Type": "application/json"
+  };
+  async function fetchContents(path) {
+    const res = await fetch(
+      `${GITHUB_API3}/repos/${repoFullName}/contents/${path}?ref=${ref}`,
+      { headers }
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    return Array.isArray(data) ? data : null;
+  }
+  async function fileExists(path) {
+    const res = await fetch(
+      `${GITHUB_API3}/repos/${repoFullName}/contents/${path}?ref=${ref}`,
+      { headers, method: "HEAD" }
+    );
+    return res.ok;
+  }
+  const apps = [];
+  const appsDir = await fetchContents("apps");
+  const isMonorepo = appsDir !== null && appsDir.length > 0;
+  const hasPm2Ecosystem = await Promise.any([
+    fileExists("ecosystem.config.cjs"),
+    fileExists("ecosystem.config.js"),
+    fileExists("ecosystem.config.mjs")
+  ]).catch(() => false);
+  if (isMonorepo) {
+    const subfolders = appsDir.filter((item) => item.type === "dir");
+    const detections = await Promise.all(
+      subfolders.map(async (folder) => {
+        const folderPath = `apps/${folder.name}`;
+        const [hasNextMjs, hasNextJs, hasNextTs, hasDockerfile, hasPkgJson] = await Promise.all([
+          fileExists(`${folderPath}/next.config.mjs`),
+          fileExists(`${folderPath}/next.config.js`),
+          fileExists(`${folderPath}/next.config.ts`),
+          fileExists(`${folderPath}/Dockerfile`),
+          fileExists(`${folderPath}/package.json`)
+        ]);
+        const hasNextConfig = hasNextMjs || hasNextJs || hasNextTs;
+        const deployMethod = inferDeployMethod(
+          folder.name,
+          hasNextConfig,
+          hasDockerfile,
+          !!hasPm2Ecosystem
+        );
+        return {
+          path: folderPath,
+          label: toLabel(folder.name),
+          deployMethod,
+          hasNextConfig,
+          hasDockerfile,
+          hasPackageJson: hasPkgJson,
+          enabled: true
+        };
+      })
+    );
+    apps.push(...detections);
+  } else {
+    const [hasNextMjs, hasNextJs, hasNextTs, hasDockerfile, hasPkgJson] = await Promise.all([
+      fileExists("next.config.mjs"),
+      fileExists("next.config.js"),
+      fileExists("next.config.ts"),
+      fileExists("Dockerfile"),
+      fileExists("package.json")
+    ]);
+    const hasNextConfig = hasNextMjs || hasNextJs || hasNextTs;
+    const repoName = repoFullName.split("/").pop() ?? "app";
+    const deployMethod = inferDeployMethod(
+      repoName,
+      hasNextConfig,
+      hasDockerfile,
+      !!hasPm2Ecosystem
+    );
+    apps.push({
+      path: ".",
+      label: toLabel(repoName),
+      deployMethod,
+      hasNextConfig,
+      hasDockerfile,
+      hasPackageJson: hasPkgJson,
+      enabled: true
+    });
+  }
+  const workDirectory = isMonorepo ? apps.find((a) => a.deployMethod !== "none")?.path ?? "." : ".";
+  const hasTriggerDev = await Promise.any([
+    fileExists("packages/jobs/trigger.config.ts"),
+    fileExists("trigger.config.ts")
+  ]).catch(() => false);
+  return {
+    isMonorepo,
+    apps,
+    workDirectory,
+    hasTriggerDev: !!hasTriggerDev
+  };
+}
+var QUICK_STAGE_DEFAULTS = {
+  dev: {
+    name: "Development",
+    releaseBranch: "release-dev",
+    triggerMode: "pr_webhook",
+    autoApprove: true,
+    requireReview: false,
+    backupDb: false,
+    migrateDb: true
+  },
+  staging: {
+    name: "Staging",
+    releaseBranch: "release-staging",
+    triggerMode: "manual",
+    autoApprove: false,
+    requireReview: false,
+    backupDb: true,
+    migrateDb: true
+  },
+  prod: {
+    name: "Production",
+    releaseBranch: "release-prod",
+    triggerMode: "manual",
+    autoApprove: false,
+    requireReview: false,
+    backupDb: true,
+    migrateDb: true
+  }
+};
+var QUICK_STAGES_FOR_TYPE = {
+  dev_only: ["dev"],
+  prod_only: ["prod"],
+  both: ["dev", "prod"]
+};
+function deriveProfileName(repoFullName) {
+  const repoName = repoFullName.split("/").pop() ?? repoFullName;
+  return repoName.split(/[-_]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function toStageApps(apps) {
+  return apps.filter((a) => a.enabled).map((a) => ({
+    path: a.path,
+    label: a.label,
+    deployMethod: a.deployMethod,
+    deploymentAppId: null,
+    deploymentServerId: null,
+    deployPath: null,
+    deployScript: null,
+    enabled: a.enabled
+  }));
+}
+async function ensureGitHubBranchExists(repoFullName, branchName, fromBranch, githubToken) {
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    Authorization: `Bearer ${githubToken}`,
+    "Content-Type": "application/json"
+  };
+  const checkRes = await fetch(
+    `${GITHUB_API3}/repos/${repoFullName}/git/ref/heads/${branchName}`,
+    { headers }
+  );
+  if (checkRes.ok) return;
+  let sha;
+  const sourceRes = await fetch(
+    `${GITHUB_API3}/repos/${repoFullName}/git/ref/heads/${fromBranch}`,
+    { headers }
+  );
+  if (sourceRes.ok) {
+    const data = await sourceRes.json();
+    sha = data.object?.sha;
+  } else {
+    const repoRes = await fetch(`${GITHUB_API3}/repos/${repoFullName}`, {
+      headers
+    });
+    if (!repoRes.ok) {
+      throw new Error(`Could not access repository ${repoFullName}`);
+    }
+    const repo = await repoRes.json();
+    const defaultBranch = repo.default_branch ?? "main";
+    const defaultRes = await fetch(
+      `${GITHUB_API3}/repos/${repoFullName}/git/ref/heads/${defaultBranch}`,
+      { headers }
+    );
+    if (!defaultRes.ok) {
+      throw new Error(`Could not resolve a source branch for ${repoFullName}`);
+    }
+    const data = await defaultRes.json();
+    sha = data.object?.sha;
+  }
+  if (!sha) {
+    throw new Error(`Could not determine SHA to create branch ${branchName}`);
+  }
+  const createRes = await fetch(
+    `${GITHUB_API3}/repos/${repoFullName}/git/refs`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ ref: `refs/heads/${branchName}`, sha })
+    }
+  );
+  if (!createRes.ok && createRes.status !== 422) {
+    const body = await createRes.text().catch(() => "");
+    throw new Error(
+      `Failed to create branch ${branchName}: ${createRes.status} ${body}`
+    );
+  }
+}
+async function insertQuickStages(profileId, releaseType, stageApps) {
+  const db2 = getDb();
+  const stages = [];
+  const wanted = QUICK_STAGES_FOR_TYPE[releaseType];
+  for (let i = 0; i < wanted.length; i++) {
+    const stageType = wanted[i];
+    const defaults = QUICK_STAGE_DEFAULTS[stageType];
+    const rows = await db2.execute(sql`
+      INSERT INTO release_profile_stage (
+        release_profile_id, name, stage, stage_order, release_branch,
+        trigger_mode, auto_approve, require_review,
+        backup_db, migrate_db, stage_apps, enabled,
+        trigger_branch, trigger_event
+      ) VALUES (
+        ${profileId}, ${defaults.name}, ${stageType}, ${i + 1},
+        ${defaults.releaseBranch},
+        ${defaults.triggerMode}, ${defaults.autoApprove}, ${defaults.requireReview},
+        ${defaults.backupDb}, ${defaults.migrateDb},
+        ${JSON.stringify(stageApps)}::jsonb, true,
+        ${defaults.releaseBranch}, 'push'
+      )
+      RETURNING id, name, stage, release_branch, trigger_mode
+    `);
+    if (rows[0]) stages.push(rows[0]);
+  }
+  return stages;
+}
+async function quickCreateReleaseProfile(userId, options) {
+  const db2 = getDb();
+  const repoFullName = options.repoFullName.trim();
+  if (!repoFullName.includes("/")) {
+    throw new ReleaseProfileQuickCreateError(
+      `Repository must be in "owner/name" format, got "${repoFullName}"`,
+      "BAD_REQUEST"
+    );
+  }
+  const existing = await db2.execute(sql`
+    SELECT id, name FROM release_profile
+    WHERE lower(repo_full_name) = ${repoFullName.toLowerCase()}
+    LIMIT 1
+  `);
+  if (existing[0]) {
+    throw new ReleaseProfileQuickCreateError(
+      `Repository ${repoFullName} already has a release profile ("${existing[0].name}")`,
+      "CONFLICT"
+    );
+  }
+  const githubTokenId = options.githubTokenId ?? null;
+  const { token, error: tokenError } = await resolveReleaseGitHubToken(githubTokenId);
+  if (!token) {
+    throw new ReleaseProfileQuickCreateError(
+      tokenError || "GitHub token is not configured",
+      "PRECONDITION_FAILED"
+    );
+  }
+  let scan;
+  try {
+    scan = await scanRepoForApps(repoFullName, token);
+  } catch (err) {
+    throw new ReleaseProfileQuickCreateError(
+      `Failed to scan repository ${repoFullName}: ${err instanceof Error ? err.message : String(err)}`,
+      "BAD_REQUEST"
+    );
+  }
+  const name = options.name?.trim() || deriveProfileName(repoFullName);
+  const releaseType = options.releaseType ?? "both";
+  const detectedApps = toStageApps(scan.apps);
+  let profile;
+  try {
+    const rows = await db2.execute(sql`
+      INSERT INTO release_profile (
+        name, repo_full_name, work_directory, enabled, release_type,
+        current_version, active_version, created_by, use_changes_branch,
+        detected_apps, has_trigger_dev, github_token_id
+      ) VALUES (
+        ${name}, ${repoFullName}, ${scan.workDirectory}, true, ${releaseType},
+        NULL, NULL, ${userId}, false,
+        ${JSON.stringify(detectedApps)}::jsonb, ${scan.hasTriggerDev},
+        ${githubTokenId}
+      )
+      RETURNING *
+    `);
+    profile = rows[0];
+  } catch (err) {
+    throw new ReleaseProfileQuickCreateError(
+      `Failed to create release profile: ${err instanceof Error ? err.message : String(err)}`,
+      "INTERNAL_SERVER_ERROR"
+    );
+  }
+  if (!profile) {
+    throw new ReleaseProfileQuickCreateError(
+      "Release profile insert returned no rows",
+      "INTERNAL_SERVER_ERROR"
+    );
+  }
+  const stages = await insertQuickStages(profile.id, releaseType, detectedApps);
+  const branchWarnings = [];
+  for (const stage of stages) {
+    if (!stage.release_branch) continue;
+    try {
+      await ensureGitHubBranchExists(
+        repoFullName,
+        stage.release_branch,
+        "main",
+        token
+      );
+    } catch (err) {
+      branchWarnings.push(
+        `Could not create branch ${stage.release_branch}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { profile, stages, scan, branchWarnings };
+}
+async function updateReleaseProfileSettings(profileId, fields) {
+  const db2 = getDb();
+  const profileRows = await db2.execute(sql`
+    SELECT id, release_type, detected_apps
+    FROM release_profile WHERE id = ${profileId} LIMIT 1
+  `);
+  const current = profileRows[0];
+  if (!current) {
+    throw new ReleaseProfileQuickCreateError(
+      "Release profile not found",
+      "NOT_FOUND"
+    );
+  }
+  const setExprs = [];
+  if (fields.name !== void 0) setExprs.push(sql`name = ${fields.name}`);
+  if (fields.enabled !== void 0)
+    setExprs.push(sql`enabled = ${fields.enabled}`);
+  if (fields.releaseType !== void 0)
+    setExprs.push(sql`release_type = ${fields.releaseType}`);
+  if (fields.githubTokenId !== void 0)
+    setExprs.push(sql`github_token_id = ${fields.githubTokenId}`);
+  if (fields.useChangesBranch !== void 0)
+    setExprs.push(sql`use_changes_branch = ${fields.useChangesBranch}`);
+  if (fields.hasTriggerDev !== void 0)
+    setExprs.push(sql`has_trigger_dev = ${fields.hasTriggerDev}`);
+  if (fields.workDirectory !== void 0)
+    setExprs.push(sql`work_directory = ${fields.workDirectory}`);
+  if (setExprs.length === 0) {
+    throw new ReleaseProfileQuickCreateError(
+      "No fields to update",
+      "BAD_REQUEST"
+    );
+  }
+  const rows = await db2.execute(sql`
+    UPDATE release_profile
+    SET ${sql.join(setExprs, sql`, `)}
+    WHERE id = ${profileId}
+    RETURNING *
+  `);
+  const profile = rows[0];
+  if (!profile) {
+    throw new ReleaseProfileQuickCreateError(
+      "Release profile update returned no rows",
+      "INTERNAL_SERVER_ERROR"
+    );
+  }
+  let stagesReconfigured = false;
+  if (fields.releaseType !== void 0 && fields.releaseType !== current.release_type) {
+    await reconfigureQuickStages(
+      profileId,
+      fields.releaseType,
+      current.detected_apps ?? []
+    );
+    stagesReconfigured = true;
+  }
+  return { profile, stagesReconfigured };
+}
+async function reconfigureQuickStages(profileId, releaseType, detectedApps) {
+  const db2 = getDb();
+  const wanted = QUICK_STAGES_FOR_TYPE[releaseType];
+  const existingStages = await db2.execute(sql`
+    SELECT id, stage, release_branch
+    FROM release_profile_stage
+    WHERE release_profile_id = ${profileId}
+  `);
+  const existingByStage = new Map(existingStages.map((s) => [s.stage, s]));
+  for (let i = 0; i < wanted.length; i++) {
+    const stageType = wanted[i];
+    const defaults = QUICK_STAGE_DEFAULTS[stageType];
+    const existing = existingByStage.get(stageType);
+    if (existing) {
+      await db2.execute(sql`
+        UPDATE release_profile_stage
+        SET stage_order = ${i + 1},
+            release_branch = ${existing.release_branch ?? defaults.releaseBranch},
+            enabled = true
+        WHERE id = ${existing.id}
+      `);
+    } else {
+      await db2.execute(sql`
+        INSERT INTO release_profile_stage (
+          release_profile_id, name, stage, stage_order, release_branch,
+          trigger_mode, auto_approve, require_review,
+          backup_db, migrate_db, stage_apps, enabled,
+          trigger_branch, trigger_event
+        ) VALUES (
+          ${profileId}, ${defaults.name}, ${stageType}, ${i + 1},
+          ${defaults.releaseBranch},
+          ${defaults.triggerMode}, ${defaults.autoApprove}, ${defaults.requireReview},
+          ${defaults.backupDb}, ${defaults.migrateDb},
+          ${JSON.stringify(detectedApps)}::jsonb, true,
+          ${defaults.releaseBranch}, 'push'
+        )
+      `);
+    }
+  }
+  const wantedSet = new Set(wanted);
+  for (const existing of existingStages) {
+    if (wantedSet.has(existing.stage)) continue;
+    await db2.execute(sql`
+      UPDATE release_profile_stage SET enabled = false WHERE id = ${existing.id}
+    `);
+  }
+}
 var args = process.argv.slice(2);
 function getArg2(name) {
   return args.find((a) => a.startsWith(`--${name}=`))?.split("=").slice(1).join("=");
@@ -5853,6 +6331,9 @@ var TOOL_MODULE_MAP = {
   "env-get": "ci_cd",
   "env-store": "ci_cd",
   "release-trigger": "ci_cd",
+  "release-profile-list": "ci_cd",
+  "release-profile-create": "ci_cd",
+  "release-profile-update": "ci_cd",
   "domain-list": "domains",
   "dns-list": "domains",
   "dns-record": "domains",
@@ -6233,6 +6714,23 @@ async function resolveReleaseProfileStageIds(profileName) {
   }
   return { stageIds: stages.map((s) => s.id), profileId: profile.id };
 }
+async function resolveGitHubTokenIdByKey(key) {
+  const trimmed = key.trim();
+  const rows = await db.execute(sql`
+    SELECT id FROM github_token
+    WHERE label ILIKE ${trimmed} OR owner ILIKE ${trimmed} OR id::text = ${trimmed}
+    ORDER BY label
+    LIMIT 1
+  `);
+  if (rows[0]) return rows[0].id;
+  const all = await db.execute(
+    sql`SELECT label, owner FROM github_token ORDER BY label`
+  );
+  const available = all.map((t) => t.owner ? `${t.label} (${t.owner})` : t.label).join(", ");
+  throw new Error(
+    `GitHub key "${key}" not found. Available keys: ${available || "(none)"}. Omit githubKey to use the default MG Software token.`
+  );
+}
 async function resolveReleaseTriggerStage(profileName, stageFilter) {
   const profileRows = await db.execute(sql`
     SELECT id, name FROM release_profile
@@ -8397,11 +8895,11 @@ CREATE TABLE IF NOT EXISTS _mcp_migrations (
   applied_by  TEXT
 );
 `.trim();
-function normaliseMigrationSql(sql27) {
-  return sql27.replace(/\r\n/g, "\n").trim() + "\n";
+function normaliseMigrationSql(sql28) {
+  return sql28.replace(/\r\n/g, "\n").trim() + "\n";
 }
-function migrationSha256(sql27) {
-  return createHash("sha256").update(normaliseMigrationSql(sql27), "utf8").digest("hex");
+function migrationSha256(sql28) {
+  return createHash("sha256").update(normaliseMigrationSql(sql28), "utf8").digest("hex");
 }
 function dollarQuoteTag(value) {
   let tag = "_mcp";
@@ -9468,6 +9966,79 @@ var TOOLS = [
       required: ["releaseProfile"]
     }
   },
+  {
+    name: "release-profile-list",
+    description: "List all release profiles with repo, enabled state, release type, GitHub key and a summary of their stages. Requires ci_cd permission.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "release-profile-create",
+    description: "One-step release profile creation: scans the GitHub repo, detects apps (Next.js/Docker/PM2), creates the profile plus dev/prod stages with smart defaults (dev: release-dev + PR webhook + auto-approve, prod: release-prod + manual + DB backup) and seeds the stage apps. Release branches are created on GitHub automatically. Deployment servers must be assigned afterwards in the dashboard (Releases \u2192 Profiles). Requires ci_cd permission.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repoFullName: {
+          type: "string",
+          description: 'Repository in "owner/name" format (e.g. MGSoftwareBV/mg-dashboard).'
+        },
+        githubKey: {
+          type: "string",
+          description: 'Named GitHub key (github_token label or owner, e.g. "AVARC Solutions") used for all GitHub API calls for this profile. Omit for the default MG Software token.'
+        },
+        name: {
+          type: "string",
+          description: 'Profile name override. Default: title-cased repo name (mg-dashboard \u2192 "Mg Dashboard").'
+        },
+        releaseType: {
+          type: "string",
+          enum: ["dev_only", "prod_only", "both"],
+          description: "Which stages to create (default: both = dev + prod)."
+        }
+      },
+      required: ["repoFullName"]
+    }
+  },
+  {
+    name: "release-profile-update",
+    description: "Update release profile settings. Locate the profile by name or repo. Changing releaseType reconfigures the stages (missing stages are created with smart defaults, out-of-scope stages are disabled). Requires ci_cd permission.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        releaseProfile: {
+          type: "string",
+          description: "Profile name or repo full name to locate the profile."
+        },
+        name: { type: "string", description: "New profile name." },
+        enabled: { type: "boolean", description: "Enable/disable the profile." },
+        releaseType: {
+          type: "string",
+          enum: ["dev_only", "prod_only", "both"],
+          description: "New release type \u2014 reconfigures stages accordingly."
+        },
+        githubKey: {
+          type: "string",
+          description: 'Named GitHub key (github_token label or owner). Pass "default" to reset to the default MG Software token.'
+        },
+        useChangesBranch: {
+          type: "boolean",
+          description: "Use a long-lived -changes accumulation branch."
+        },
+        hasTriggerDev: {
+          type: "boolean",
+          description: "Deploy Trigger.dev jobs during production releases."
+        },
+        workDirectory: {
+          type: "string",
+          description: 'Working directory within the repo (e.g. ".").'
+        }
+      },
+      required: ["releaseProfile"]
+    }
+  },
   {
     name: "cache-purge",
     description: 'Purge caches on a server. Default mode is **safe** (recommended): LiteSpeed file cache, WordPress/LiteSpeed plugin caches via wp-cli, PrestaShop file caches, graceful LiteSpeed reload \u2014 does NOT kill lsphp, FLUSHALL Redis, or hard-restart the web server.\n\nUse `mode: "full"` only when safe purge is insufficient: kills all lsphp (OPcache reset), clears Redis/Memcached entirely, and may hard-restart LiteSpeed \u2014 can briefly take sites offline or serve stale error pages until caches warm up (VCA multi-site risk).',
@@ -9567,7 +10138,7 @@ var TOOLS = [
   // ----- Trigger.dev -----
   ...TRIGGER_TOOLS
 ];
-var MCP_VERSION = "7.0.0";
+var MCP_VERSION = "7.0.5";
 async function handleListTools() {
   if (!authContext) return { tools: TOOLS };
   const accessible = TOOLS.filter((tool) => {
@@ -12009,6 +12580,170 @@ LIMIT ${limit};
           throw err;
         }
       }
+      case "release-profile-list": {
+        const profiles = await db.execute(sql`
+          SELECT
+            p.id, p.name, p.repo_full_name, p.enabled, p.release_type,
+            p.work_directory, p.use_changes_branch, p.has_trigger_dev,
+            gt.label AS github_key,
+            (
+              SELECT string_agg(
+                s.stage || ' (' || COALESCE(s.release_branch, '-') ||
+                  ', ' || COALESCE(s.trigger_mode, 'manual') ||
+                  CASE WHEN s.enabled THEN '' ELSE ', disabled' END || ')',
+                '; ' ORDER BY s.stage_order
+              )
+              FROM release_profile_stage s
+              WHERE s.release_profile_id = p.id
+            ) AS stages
+          FROM release_profile p
+          LEFT JOIN github_token gt ON gt.id = p.github_token_id
+          ORDER BY p.name
+        `);
+        if (profiles.length === 0) {
+          return {
+            content: [{ type: "text", text: "No release profiles found" }]
+          };
+        }
+        const lines = profiles.map((p) => {
+          const flags = [
+            p.enabled ? "enabled" : "disabled",
+            `type=${p.release_type ?? "both"}`,
+            `key=${p.github_key ?? "MG Software (default)"}`,
+            p.use_changes_branch ? "changes-branch" : null,
+            p.has_trigger_dev ? "trigger.dev" : null
+          ].filter(Boolean).join(", ");
+          return `${p.name} \u2014 ${p.repo_full_name} [${flags}]
+  stages: ${p.stages ?? "(none)"}`;
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${profiles.length} release profile(s):
+
+${lines.join("\n\n")}`
+            }
+          ]
+        };
+      }
+      case "release-profile-create": {
+        const repoFullName = String(a.repoFullName ?? "").trim();
+        const githubTokenId = a.githubKey ? await resolveGitHubTokenIdByKey(String(a.githubKey)) : null;
+        const releaseType = a.releaseType ? String(a.releaseType) : null;
+        if (releaseType !== null && releaseType !== "dev_only" && releaseType !== "prod_only" && releaseType !== "both") {
+          throw new Error(
+            `Invalid releaseType "${releaseType}". Expected dev_only, prod_only, or both.`
+          );
+        }
+        try {
+          const result = await quickCreateReleaseProfile(
+            authContext.userId,
+            {
+              repoFullName,
+              githubTokenId,
+              name: a.name ? String(a.name) : null,
+              releaseType
+            }
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    profileId: result.profile.id,
+                    name: result.profile.name,
+                    repo: repoFullName,
+                    releaseType: releaseType ?? "both",
+                    appsDetected: result.scan.apps.map((app) => ({
+                      path: app.path,
+                      label: app.label,
+                      deployMethod: app.deployMethod
+                    })),
+                    stages: result.stages.map((s) => ({
+                      stage: s.stage,
+                      name: s.name,
+                      releaseBranch: s.release_branch,
+                      triggerMode: s.trigger_mode
+                    })),
+                    branchWarnings: result.branchWarnings,
+                    hint: "Assign deployment servers per stage app in the dashboard (Releases \u2192 Profiles) before triggering a release."
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        } catch (err) {
+          if (err instanceof ReleaseProfileQuickCreateError) {
+            throw new Error(err.message);
+          }
+          throw err;
+        }
+      }
+      case "release-profile-update": {
+        const identifier = String(a.releaseProfile ?? "").trim();
+        const profileRows = await db.execute(sql`
+          SELECT id, name FROM release_profile
+          WHERE name ILIKE ${identifier} OR repo_full_name ILIKE ${identifier}
+          LIMIT 1
+        `);
+        const profile = profileRows[0];
+        if (!profile) {
+          const all = await db.execute(
+            sql`SELECT name FROM release_profile ORDER BY name`
+          );
+          throw new Error(
+            `Release profile "${identifier}" not found. Available profiles: ${all.map((p) => p.name).join(", ") || "(none)"}`
+          );
+        }
+        const releaseType = a.releaseType ? String(a.releaseType) : void 0;
+        if (releaseType !== void 0 && releaseType !== "dev_only" && releaseType !== "prod_only" && releaseType !== "both") {
+          throw new Error(
+            `Invalid releaseType "${releaseType}". Expected dev_only, prod_only, or both.`
+          );
+        }
+        let githubTokenId;
+        if (a.githubKey !== void 0) {
+          const key = String(a.githubKey).trim();
+          githubTokenId = !key || key.toLowerCase() === "default" ? null : await resolveGitHubTokenIdByKey(key);
+        }
+        try {
+          const result = await updateReleaseProfileSettings(profile.id, {
+            name: a.name !== void 0 ? String(a.name) : void 0,
+            enabled: a.enabled !== void 0 ? a.enabled === true : void 0,
+            releaseType,
+            githubTokenId,
+            useChangesBranch: a.useChangesBranch !== void 0 ? a.useChangesBranch === true : void 0,
+            hasTriggerDev: a.hasTriggerDev !== void 0 ? a.hasTriggerDev === true : void 0,
+            workDirectory: a.workDirectory !== void 0 ? String(a.workDirectory) : void 0
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    profileId: profile.id,
+                    name: result.profile.name,
+                    updated: true,
+                    stagesReconfigured: result.stagesReconfigured
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        } catch (err) {
+          if (err instanceof ReleaseProfileQuickCreateError) {
+            throw new Error(err.message);
+          }
+          throw err;
+        }
+      }
       // ----- Cache Purge -----
       case "cache-purge": {
         const { conn, proxy } = await getServerConnection(String(a.serverId));