@agilemonster/mcp-server 1.0.16 → 1.0.22

package/dist/deploy-profile.js

@@ -0,0 +1,993 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+// ---------------------------------------------------------------------------
+// Small helpers
+// ---------------------------------------------------------------------------
+function readText(file, maxBytes = 120000) {
+    try {
+        if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+            return '';
+        return fs.readFileSync(file, 'utf8').slice(0, maxBytes);
+    }
+    catch {
+        return '';
+    }
+}
+function exists(...parts) {
+    try {
+        return fs.existsSync(path.join(...parts));
+    }
+    catch {
+        return false;
+    }
+}
+function isInside(child, parent) {
+    const c = path.resolve(child);
+    const p = path.resolve(parent);
+    return c === p || c.startsWith(p.endsWith(path.sep) ? p : p + path.sep);
+}
+export function normalizeMethod(raw) {
+    const v = (raw || '').toLowerCase().trim().replace(/[\s-]+/g, '_');
+    if (!v)
+        return null;
+    if (['docker_compose', 'docker', 'compose', 'docker_compose_up', 'container', 'containers'].includes(v)) {
+        return 'docker_compose';
+    }
+    if (['github_actions', 'github', 'gha', 'actions', 'ci', 'ci_cd', 'cicd', 'github_action'].includes(v)) {
+        return 'github_actions';
+    }
+    if (['deploy_script', 'script', 'ssh', 'sh', 'shell', 'make', 'rsync', 'ftp', 'sftp'].includes(v)) {
+        return 'deploy_script';
+    }
+    if (['cloud_cli', 'cli', 'vercel', 'netlify', 'fly', 'firebase', 'wrangler', 'cloudflare'].includes(v)) {
+        return 'cloud_cli';
+    }
+    if (['git_push', 'push', 'git'].includes(v))
+        return 'git_push';
+    if (['manual', 'human', 'me'].includes(v))
+        return 'manual';
+    if (['none', 'skip', 'no', 'off', 'no_deploy'].includes(v))
+        return 'none';
+    return null;
+}
+/**
+ * Older versions stored descriptions such as "git push origin HEAD (GitHub Actions CI/CD)" in the command
+ * field. Those are not commands. (Real commands may contain parentheses, e.g. `TAG=$(git rev-parse HEAD)`.)
+ */
+export function isRunnableCommand(cmd) {
+    const c = (cmd || '').trim();
+    return c.length > 0 && !/\((GitHub Actions|CI\/CD)[^)]*\)\s*$/i.test(c);
+}
+export function globToRegExp(glob) {
+    let re = '';
+    for (let i = 0; i < glob.length; i++) {
+        const ch = glob[i];
+        if (ch === '*') {
+            if (glob[i + 1] === '*') {
+                re += '.*';
+                i++;
+                if (glob[i + 1] === '/')
+                    i++;
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (ch === '[') {
+            // character class, as in release/v[0-9]
+            const close = glob.indexOf(']', i + 1);
+            if (close > i) {
+                re += glob.slice(i, close + 1);
+                i = close;
+            }
+            else {
+                re += '\\[';
+            }
+        }
+        else if ((ch === '?' || ch === '+') && i > 0) {
+            // GitHub filter patterns: `?` = zero or one, `+` = one or more of the preceding character
+            re += ch;
+        }
+        else {
+            re += ch.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+function matchesAny(patterns, value) {
+    let matched = false;
+    for (const raw of patterns) {
+        const negate = raw.startsWith('!');
+        const pattern = negate ? raw.slice(1) : raw;
+        if (globToRegExp(pattern).test(value)) {
+            matched = !negate;
+        }
+    }
+    return matched;
+}
+// ---------------------------------------------------------------------------
+// GitHub Actions workflows
+// ---------------------------------------------------------------------------
+function stripComment(line) {
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === "'" && !inDouble)
+            inSingle = !inSingle;
+        else if (ch === '"' && !inSingle)
+            inDouble = !inDouble;
+        else if (ch === '#' && !inSingle && !inDouble && (i === 0 || /\s/.test(line[i - 1]))) {
+            return line.slice(0, i);
+        }
+    }
+    return line;
+}
+function unquote(s) {
+    return s.trim().replace(/^["']|["']$/g, '').trim();
+}
+function parseFlowList(value) {
+    const v = value.trim();
+    if (v.startsWith('[')) {
+        return v
+            .replace(/^\[|\]$/g, '')
+            .split(',')
+            .map(unquote)
+            .filter((s) => s.length > 0);
+    }
+    return v ? [unquote(v)] : [];
+}
+function indentOf(line) {
+    return line.length - line.trimStart().length;
+}
+/** Read a `key:` under an event block as a list, whether written inline (`[a, b]`) or as `- a` lines. */
+function readListKey(block, key) {
+    for (let i = 0; i < block.length; i++) {
+        const m = block[i].match(new RegExp(`^(\\s*)${key}\\s*:\\s*(.*)$`));
+        if (!m)
+            continue;
+        const baseIndent = m[1].length;
+        let inline = m[2].trim();
+        if (inline.startsWith('[') && !inline.includes(']')) {
+            // flow list spread over several lines
+            for (let j = i + 1; j < block.length && !inline.includes(']'); j++)
+                inline += ` ${block[j].trim()}`;
+        }
+        if (inline)
+            return parseFlowList(inline);
+        const items = [];
+        for (let j = i + 1; j < block.length; j++) {
+            const line = block[j];
+            if (!line.trim())
+                continue;
+            if (indentOf(line) <= baseIndent && !line.trim().startsWith('-'))
+                break;
+            const item = line.trim().match(/^-\s*(.+)$/);
+            if (item)
+                items.push(unquote(item[1]));
+            else if (indentOf(line) <= baseIndent)
+                break;
+        }
+        return items;
+    }
+    return null;
+}
+const DEPLOY_STEP_RE = /appleboy\/(ssh|scp)-action|SamKirkland\/FTP-Deploy-Action|ftp-deploy|easingthemes\/ssh-deploy|burnett01\/rsync-deployments|\brsync\s+-|\bscp\s+-|\bsftp\b|\blftp\b|\bssh\s+(-\S+\s+)*\S+@|aws\s+s3\s+(sync|cp)|firebase\s+deploy|firebase-hosting|vercel\s+(deploy|--prod)|amondnet\/vercel-action|netlify\s+deploy|nwtgck\/actions-netlify|wrangler\s+(deploy|publish)|cloudflare\/(wrangler-action|pages-action)|fly(ctl)?\s+deploy|superfly\/flyctl-actions|docker\s+push|docker\/build-push-action|gcloud\s+(run|app|functions)\s+deploy|kubectl\s+(apply|set|rollout)|helm\s+upgrade|azure\/webapps-deploy|peaceiris\/actions-gh-pages|actions\/deploy-pages|npm\s+publish|\buapi\b|cpanel/i;
+export function parseWorkflow(file, text) {
+    const lines = text.split(/\r?\n/).map(stripComment);
+    const nameLine = lines.find((l) => /^name\s*:/.test(l));
+    const name = nameLine ? unquote(nameLine.replace(/^name\s*:/, '')) : path.basename(file).replace(/\.ya?ml$/i, '');
+    const events = [];
+    let push = null;
+    let dispatch = false;
+    let workflowRun = null;
+    const onIdx = lines.findIndex((l) => /^(on|"on"|'on'|true)\s*:/.test(l));
+    if (onIdx >= 0) {
+        const inline = lines[onIdx].replace(/^(on|"on"|'on'|true)\s*:/, '').trim();
+        if (inline) {
+            if (inline.startsWith('{')) {
+                for (const ev of inline.match(/[a-z_]+(?=\s*:)/g) || [])
+                    events.push(ev);
+            }
+            else {
+                events.push(...parseFlowList(inline));
+            }
+        }
+        else {
+            const block = [];
+            for (let i = onIdx + 1; i < lines.length; i++) {
+                const line = lines[i];
+                // `- push` items may sit at column 0 directly under `on:`
+                if (line.trim() && indentOf(line) === 0 && !line.startsWith('-'))
+                    break;
+                block.push(line);
+            }
+            const firstReal = block.find((l) => l.trim().length > 0);
+            const eventIndent = firstReal ? indentOf(firstReal) : 2;
+            for (let i = 0; i < block.length; i++) {
+                const line = block[i];
+                if (!line.trim() || indentOf(line) !== eventIndent)
+                    continue;
+                const m = line.trim().match(/^-?\s*([a-z_]+)\s*:?\s*(.*)$/);
+                if (!m)
+                    continue;
+                const event = m[1];
+                events.push(event);
+                let sub = [];
+                for (let j = i + 1; j < block.length; j++) {
+                    if (block[j].trim() && indentOf(block[j]) <= eventIndent)
+                        break;
+                    sub.push(block[j]);
+                }
+                const inlineMap = m[2].trim();
+                if (inlineMap.startsWith('{')) {
+                    // `push: { branches: [main], paths: [src/**] }` -> one key per line so the same reader applies
+                    sub = inlineMap
+                        .replace(/^\{|\}$/g, '')
+                        .split(/,(?![^[]*\])/)
+                        .map((part) => `  ${part.trim()}`);
+                }
+                if (event === 'push') {
+                    const branches = readListKey(sub, 'branches');
+                    const branchesIgnore = readListKey(sub, 'branches-ignore');
+                    const tags = readListKey(sub, 'tags');
+                    push = {
+                        branches,
+                        branchesIgnore,
+                        paths: readListKey(sub, 'paths'),
+                        pathsIgnore: readListKey(sub, 'paths-ignore'),
+                        tagsOnly: branches === null && branchesIgnore === null && tags !== null,
+                    };
+                }
+                else if (event === 'workflow_run') {
+                    workflowRun = {
+                        workflows: readListKey(sub, 'workflows') || [],
+                        branches: readListKey(sub, 'branches'),
+                    };
+                }
+            }
+        }
+    }
+    if (events.includes('push') && !push) {
+        push = { branches: null, branchesIgnore: null, paths: null, pathsIgnore: null, tagsOnly: false };
+    }
+    dispatch = events.includes('workflow_dispatch');
+    const label = `${path.basename(file)} ${name}`.toLowerCase().replace(/[-_.]+/g, ' ');
+    const negativeName = /\b(preflight|pre flight|audit|dry run|bootstrap|check|backfill|sync|refresh|fix)\b/.test(label);
+    const strongName = /\b(deploy|deployment|deploys|publish|cpanel|ship)\b/.test(label);
+    const isDeploy = strongName && !/\b(preflight|pre flight|dry run|bootstrap)\b/.test(label)
+        ? true
+        : !negativeName && DEPLOY_STEP_RE.test(text);
+    return { file, name, isDeploy, events, push, dispatch, workflowRun };
+}
+export function readWorkflows(projectPath) {
+    const dir = path.join(projectPath, '.github', 'workflows');
+    const out = [];
+    try {
+        for (const f of fs.readdirSync(dir).sort()) {
+            if (!/\.ya?ml$/i.test(f))
+                continue;
+            const text = readText(path.join(dir, f));
+            if (text)
+                out.push(parseWorkflow(f, text));
+        }
+    }
+    catch { }
+    return out;
+}
+function pushMatchesBranch(push, branch) {
+    if (push.tagsOnly)
+        return false;
+    if (push.branches && !matchesAny(push.branches, branch))
+        return false;
+    if (push.branchesIgnore && matchesAny(push.branchesIgnore, branch))
+        return false;
+    return true;
+}
+/** Does a push to `branch` start this workflow, directly or through a `workflow_run` chain? */
+export function workflowRunsOnPush(wf, branch, all, depth = 0) {
+    if (wf.push && pushMatchesBranch(wf.push, branch))
+        return true;
+    if (wf.workflowRun && depth < 3) {
+        if (wf.workflowRun.branches && !matchesAny(wf.workflowRun.branches, branch))
+            return false;
+        const upstreamNames = wf.workflowRun.workflows.map((w) => w.toLowerCase());
+        return all.some((other) => other !== wf &&
+            upstreamNames.includes(other.name.toLowerCase()) &&
+            workflowRunsOnPush(other, branch, all, depth + 1));
+    }
+    return false;
+}
+/** With `paths:` filters, a commit that touches none of them does not start the workflow. */
+export function pushPathsMatch(push, files) {
+    if (!push || files.length === 0)
+        return true;
+    if (push.paths && !files.some((f) => matchesAny(push.paths, f)))
+        return false;
+    if (push.pathsIgnore && files.every((f) => matchesAny(push.pathsIgnore, f)))
+        return false;
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Docker Compose
+// ---------------------------------------------------------------------------
+export const COMPOSE_PS_FORMAT = '{{.Label "com.docker.compose.project"}}\t{{.Label "com.docker.compose.project.working_dir"}}\t{{.Label "com.docker.compose.project.config_files"}}\t{{.Label "com.docker.compose.service"}}\t{{.State}}';
+const COMPOSE_NAME_RE = /^(docker-)?compose([._-][\w.-]+)?\.ya?ml$/i;
+export function findComposeFiles(projectPath) {
+    const dirs = ['', 'deploy', 'docker', 'infra', 'infra/docker', 'ops', 'deployment', '.docker', 'compose'];
+    try {
+        for (const entry of fs.readdirSync(path.join(projectPath, 'docker'), { withFileTypes: true })) {
+            if (entry.isDirectory())
+                dirs.push(`docker/${entry.name}`);
+        }
+    }
+    catch { }
+    const found = [];
+    for (const dir of dirs) {
+        let names = [];
+        try {
+            names = fs.readdirSync(path.join(projectPath, dir));
+        }
+        catch {
+            continue;
+        }
+        for (const name of names.sort()) {
+            if (!COMPOSE_NAME_RE.test(name))
+                continue;
+            const rel = dir ? `${dir}/${name}` : name;
+            const text = readText(path.join(projectPath, rel));
+            const lower = name.toLowerCase();
+            const kind = /^(docker-)?compose\.ya?ml$/.test(lower)
+                ? 'default'
+                : /(local|dev|test|override)/.test(lower)
+                    ? 'dev'
+                    : /(prod|production|staging|server)/.test(lower)
+                        ? 'prod'
+                        : 'other';
+            found.push({ rel, kind, hasBuild: /^\s+build\s*:/m.test(text) });
+        }
+    }
+    return found;
+}
+/** Parse the docker ps probe and keep the compose projects that were started from inside `projectPath`. */
+export function parseComposeStacks(psOutput, projectPath) {
+    const byProject = new Map();
+    for (const line of psOutput.split(/\r?\n/)) {
+        const [projectName, workingDir, configFiles, service, state] = line.split('\t');
+        if (!projectName || !workingDir)
+            continue;
+        const files = (configFiles || '').split(',').map((f) => f.trim()).filter(Boolean);
+        const inside = isInside(workingDir, projectPath) || files.some((f) => isInside(f, projectPath));
+        if (!inside)
+            continue;
+        const key = `${projectName}\u0000${workingDir}`;
+        let stack = byProject.get(key);
+        if (!stack) {
+            stack = { projectName, workingDir, configFiles: files, services: [], runningCount: 0 };
+            byProject.set(key, stack);
+        }
+        if (service && !stack.services.includes(service))
+            stack.services.push(service);
+        if ((state || '').trim().toLowerCase() === 'running')
+            stack.runningCount++;
+    }
+    return Array.from(byProject.values()).sort((a, b) => b.runningCount - a.runningCount);
+}
+export function composeCommand(target, tail = 'up -d --build') {
+    const parts = ['docker', 'compose'];
+    if (target.projectName)
+        parts.push('-p', target.projectName);
+    for (const f of target.files)
+        parts.push('-f', /\s/.test(f) ? `"${f}"` : f);
+    return `${parts.join(' ')} ${tail}`.trim();
+}
+/** Arguments for `docker compose …` matching a target (no shell quoting needed). */
+export function composeArgs(target) {
+    const args = ['compose'];
+    if (target.projectName)
+        args.push('-p', target.projectName);
+    for (const f of target.files)
+        args.push('-f', f);
+    return args;
+}
+let dockerPsCache = null;
+function defaultDockerPs() {
+    if (dockerPsCache && Date.now() - dockerPsCache.at < 30000)
+        return dockerPsCache.value;
+    let value = null;
+    try {
+        value = execFileSync('docker', ['ps', '-a', '--format', COMPOSE_PS_FORMAT], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000,
+        });
+    }
+    catch {
+        value = null;
+    }
+    dockerPsCache = { at: Date.now(), value };
+    return value;
+}
+// ---------------------------------------------------------------------------
+// Git
+// ---------------------------------------------------------------------------
+function defaultGitInfo(projectPath) {
+    const info = { isRepo: false, branch: null, hasRemote: false, remoteUrl: null };
+    if (!exists(projectPath, '.git'))
+        return info;
+    info.isRepo = true;
+    const git = (args) => {
+        try {
+            return execFileSync('git', args, {
+                cwd: projectPath,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 4000,
+            }).trim();
+        }
+        catch {
+            return '';
+        }
+    };
+    info.branch = git(['branch', '--show-current']) || null;
+    info.remoteUrl = git(['config', '--get', 'remote.origin.url']) || null;
+    info.hasRemote = Boolean(info.remoteUrl) || git(['remote']).length > 0;
+    return info;
+}
+// ---------------------------------------------------------------------------
+// Docs, build command, live URL
+// ---------------------------------------------------------------------------
+function deployDocFiles(projectPath) {
+    const files = [
+        'CLAUDE.md',
+        'AGENTS.md',
+        'MEMORY.md',
+        'README.md',
+        '.cursorrules',
+        'deploy/README.md',
+        'deploy/README-DEPLOY.md',
+    ];
+    for (const dir of ['', 'docs', 'deploy']) {
+        try {
+            for (const name of fs.readdirSync(path.join(projectPath, dir)).sort()) {
+                if (/^deploy.*\.md$/i.test(name) || /deploy(ment)?[-_a-z]*\.md$/i.test(name)) {
+                    const rel = dir ? `${dir}/${name}` : name;
+                    if (!files.includes(rel))
+                        files.push(rel);
+                }
+            }
+        }
+        catch { }
+    }
+    return files.filter((f) => exists(projectPath, f)).slice(0, 10);
+}
+const DEPLOY_LINE_RE = /deploy|ci\/cd|github actions|docker[ -]compose|production|rsync|cpanel|\bssh\b|go(es)? live|release|hosting|workflow/i;
+/** Pull the lines of the project docs that talk about deployment (compact, for the code model and for humans). */
+export function extractDeploymentNotes(projectPath, maxChars = 1800) {
+    const out = [];
+    const seen = new Set();
+    let total = 0;
+    for (const rel of deployDocFiles(projectPath)) {
+        const text = readText(path.join(projectPath, rel), 60000);
+        if (!text)
+            continue;
+        const picked = [];
+        for (const raw of text.split(/\r?\n/)) {
+            const line = raw.trim();
+            if (line.length < 8 || line.length > 320)
+                continue;
+            if (!DEPLOY_LINE_RE.test(line))
+                continue;
+            const key = line.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            picked.push(line);
+            if (picked.length >= 8)
+                break;
+        }
+        if (picked.length === 0)
+            continue;
+        const section = `[${rel}]\n${picked.join('\n')}`;
+        if (total + section.length > maxChars) {
+            out.push(section.slice(0, Math.max(0, maxChars - total)));
+            break;
+        }
+        out.push(section);
+        total += section.length;
+    }
+    return out.join('\n').trim();
+}
+function docHints(projectPath) {
+    const hints = { docker_compose: 0, github_actions: 0, deploy_script: 0 };
+    for (const rel of deployDocFiles(projectPath)) {
+        const text = readText(path.join(projectPath, rel), 60000);
+        for (const raw of text.split(/\r?\n/)) {
+            const line = raw.toLowerCase();
+            if (!/deploy|production|release|live/.test(line))
+                continue;
+            if (/docker[ -]compose\s+.*\bup\b|recreate the container|docker compose up/.test(line))
+                hints.docker_compose++;
+            if (/github actions|workflow|ci\/cd|\.github\/workflows/.test(line))
+                hints.github_actions++;
+            if (/deploy\.sh|make deploy|rsync|\bssh\b|deploy script/.test(line))
+                hints.deploy_script++;
+        }
+    }
+    return hints;
+}
+export function detectBuildCommand(projectPath) {
+    const pkgScript = (rel, script) => {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(projectPath, rel, 'package.json'), 'utf8'));
+            return Boolean(pkg?.scripts?.[script]);
+        }
+        catch {
+            return false;
+        }
+    };
+    const runner = (rel) => (exists(projectPath, rel, 'pnpm-lock.yaml') ? 'pnpm' : 'npm');
+    if (pkgScript('apps/web', 'build'))
+        return `cd apps/web && ${runner('apps/web')} run build`;
+    if (pkgScript('frontend', 'build'))
+        return `cd frontend && ${runner('frontend')} run build`;
+    if (pkgScript('', 'build'))
+        return `${runner('')} run build`;
+    if (exists(projectPath, 'frontend-flutter', 'pubspec.yaml'))
+        return 'cd frontend-flutter && flutter analyze';
+    if (exists(projectPath, 'pubspec.yaml'))
+        return 'flutter analyze';
+    return null;
+}
+const THIRD_PARTY_HOST_RE = /(^|\.)(github|githubusercontent|gitlab|bitbucket|openai|anthropic|google|googleapis|gstatic|npmjs|figma|stripe|vercel|netlify|cloudflare|amazonaws|apple|microsoft|docker|localhost|example|w3|schema|shields|youtube|twitter|x|linkedin|facebook|slack|discord|sentry|mozilla|wikipedia|stackoverflow|medium|notion|atlassian|flutter|dart|pub|nodejs|reactjs|nextjs|php|laravel|python|readthedocs|jsdelivr|unpkg|cdnjs|fonts|gravatar|telnyx|sendgrid|twilio|paypal|supabase|firebase|firebaseio|herokuapp|fly|render|railway|cpanel)\.[a-z.]+$/i;
+const PLACEHOLDER_HOST_RE = /localhost|127\.0\.0\.1|example\.|your-?(domain|site|app|company)|my-?(domain|site|app)\.|domain\.(com|tld)|changeme|placeholder|\.local\b|\.test\b/i;
+function normToken(s) {
+    return s
+        .toLowerCase()
+        .replace(/^www\./, '')
+        .replace(/\.(com|ai|io|app|dev|org|net|co|co\.[a-z]{2}|[a-z]{2})$/i, '')
+        .replace(/[^a-z0-9]/g, '');
+}
+/** "app.example.co.za" -> "example": the label a project name can be compared with. */
+export function registrableLabel(host) {
+    const h = host.toLowerCase().replace(/^www\./, '');
+    const withoutSuffix = /\.(co|com|org|net|ac|gov|edu)\.[a-z]{2}$/.test(h)
+        ? h.replace(/\.(co|com|org|net|ac|gov|edu)\.[a-z]{2}$/, '')
+        : h.replace(/\.[a-z]{2,}$/, '');
+    return (withoutSuffix.split('.').pop() || '').replace(/[^a-z0-9]/g, '');
+}
+/**
+ * Best-effort production URL. Returns a URL only when something ties it to this project
+ * (an APP_URL-style env value, a doc URL whose host resembles the project/repo name, or a
+ * folder literally named like a domain) — never just "the first link in the README".
+ */
+export function inferLiveUrl(projectPath, name, remoteUrl) {
+    const tokens = new Set();
+    const nameToken = normToken(name.replace(/^nieuw\.games[-_]*/i, ''));
+    if (nameToken.length >= 4)
+        tokens.add(nameToken);
+    if (remoteUrl) {
+        const repo = normToken(path.basename(remoteUrl).replace(/\.git$/i, ''));
+        if (repo.length >= 4)
+            tokens.add(repo);
+    }
+    for (const envFile of ['.env.production', '.env.example', '.env']) {
+        const text = readText(path.join(projectPath, envFile), 20000);
+        const m = text.match(/^(?:APP_URL|SITE_URL|PUBLIC_URL|BASE_URL|FRONTEND_URL|NEXT_PUBLIC_(?:SITE|APP|BASE)_URL|VITE_(?:SITE|APP)_URL)\s*=\s*["']?(https:\/\/[a-z0-9.-]+\.[a-z]{2,})/im);
+        if (m && !PLACEHOLDER_HOST_RE.test(m[1]))
+            return m[1];
+    }
+    const candidates = new Map();
+    for (const doc of ['CLAUDE.md', 'AGENTS.md', 'MEMORY.md', 'README.md']) {
+        const text = readText(path.join(projectPath, doc), 20000);
+        for (const m of text.matchAll(/https:\/\/([a-z0-9.-]+\.[a-z]{2,})/gi)) {
+            const host = m[1].toLowerCase().replace(/[.)]+$/, '');
+            if (THIRD_PARTY_HOST_RE.test(host) || PLACEHOLDER_HOST_RE.test(host))
+                continue;
+            const hostToken = registrableLabel(host);
+            if (hostToken.length < 4)
+                continue;
+            let related = false;
+            for (const t of tokens) {
+                if (hostToken.includes(t) || t.includes(hostToken))
+                    related = true;
+            }
+            if (!related)
+                continue;
+            candidates.set(host, (candidates.get(host) || 0) + 1);
+        }
+    }
+    if (candidates.size > 0) {
+        // Prefer the site itself (apex / www) over api.* or app.* subdomains, then the most-mentioned host
+        const isApex = (h) => h.replace(/^www\./, '').split('.').length === (/\.(co|com|org|net|ac|gov|edu)\.[a-z]{2}$/.test(h) ? 3 : 2);
+        const best = Array.from(candidates.entries()).sort((a, b) => Number(isApex(b[0])) - Number(isApex(a[0])) || b[1] - a[1] || a[0].length - b[0].length)[0][0];
+        return `https://${best}`;
+    }
+    const clean = name.toLowerCase().replace(/^nieuw\.games[-_]*/i, '');
+    if (/^[a-z0-9-]+\.(com|ai|io|app|dev|org|net)$/i.test(clean))
+        return `https://${clean}`;
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Candidate gathering + ranking
+// ---------------------------------------------------------------------------
+function readExplicitFile(projectPath) {
+    try {
+        const file = path.join(projectPath, '.agilemonster', 'deploy.json');
+        if (!fs.existsSync(file))
+            return null;
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const method = normalizeMethod(parsed?.method);
+        if (!method)
+            return null;
+        return {
+            method,
+            command: typeof parsed.command === 'string' && parsed.command.trim() ? parsed.command.trim() : null,
+            live_url: typeof parsed.live_url === 'string' && parsed.live_url.trim() ? parsed.live_url.trim() : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function gatherCandidates(projectPath, git, workflows, dockerPs) {
+    const candidates = [];
+    const branch = git.branch || 'main';
+    // 1. GitHub Actions: only workflows that actually deploy, judged against the branch being pushed
+    const deployWfs = workflows.filter((w) => w.isDeploy);
+    if (deployWfs.length > 0 && git.hasRemote) {
+        const onPush = deployWfs.filter((w) => workflowRunsOnPush(w, branch, workflows));
+        const dispatchable = deployWfs.filter((w) => w.dispatch);
+        if (onPush.length > 0) {
+            candidates.push({
+                method: 'github_actions',
+                command: null,
+                score: 90,
+                workflows: onPush,
+                evidence: onPush.map((w) => `.github/workflows/${w.file} ("${w.name}") deploys on push to \`${branch}\`` +
+                    (w.push?.paths ? ` when these paths change: ${w.push.paths.slice(0, 4).join(', ')}` : '') +
+                    (w.workflowRun ? ` (after "${w.workflowRun.workflows.join(', ')}" succeeds)` : '')),
+            });
+        }
+        else if (dispatchable.length > 0) {
+            const wf = dispatchable[0];
+            candidates.push({
+                method: 'github_actions',
+                command: `gh workflow run ${wf.file} --ref ${branch}`,
+                score: 55,
+                workflows: [wf],
+                dispatchOnly: true,
+                evidence: [
+                    `.github/workflows/${wf.file} ("${wf.name}") deploys only when dispatched manually — a push to \`${branch}\` does not trigger it`,
+                ],
+            });
+        }
+        else {
+            const wf = deployWfs[0];
+            const branches = wf.push?.branches || wf.workflowRun?.branches || [];
+            candidates.push({
+                method: 'github_actions',
+                command: null,
+                score: 40,
+                workflows: [wf],
+                evidence: [
+                    `.github/workflows/${wf.file} ("${wf.name}") deploys from ${branches.length ? branches.map((b) => `\`${b}\``).join(', ') : 'another branch'}, but the checked-out branch is \`${branch}\``,
+                ],
+            });
+        }
+    }
+    // 2. Deploy scripts
+    const scriptCandidates = [
+        ['deploy/deploy.sh', './deploy/deploy.sh', 'deploy/deploy.sh'],
+        ['scripts/deploy.sh', './scripts/deploy.sh', 'scripts/deploy.sh'],
+        ['deploy.sh', './deploy.sh', 'deploy.sh'],
+        ['bin/deploy', './bin/deploy', 'bin/deploy'],
+        ['scripts/deploy.mjs', 'node scripts/deploy.mjs', 'scripts/deploy.mjs'],
+        ['scripts/deploy.js', 'node scripts/deploy.js', 'scripts/deploy.js'],
+        ['scripts/deploy.py', 'python3 scripts/deploy.py', 'scripts/deploy.py'],
+    ];
+    for (const [rel, cmd, label] of scriptCandidates) {
+        if (!exists(projectPath, rel))
+            continue;
+        let command = cmd;
+        if (rel === 'deploy/deploy.sh' && readText(path.join(projectPath, rel)).includes('--skip-preflight')) {
+            command = `${cmd} --skip-preflight`;
+        }
+        candidates.push({ method: 'deploy_script', command, score: 80, evidence: [`deploy script \`${label}\` exists`] });
+        break;
+    }
+    if (!candidates.some((c) => c.method === 'deploy_script')) {
+        if (/^deploy\s*:/m.test(readText(path.join(projectPath, 'Makefile')))) {
+            candidates.push({
+                method: 'deploy_script',
+                command: 'make deploy',
+                score: 78,
+                evidence: ['Makefile has a `deploy` target'],
+            });
+        }
+        else {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(path.join(projectPath, 'package.json'), 'utf8'));
+                if (pkg?.scripts?.deploy) {
+                    candidates.push({
+                        method: 'deploy_script',
+                        command: exists(projectPath, 'pnpm-lock.yaml') ? 'pnpm run deploy' : 'npm run deploy',
+                        score: 76,
+                        evidence: ['package.json has a `deploy` script'],
+                    });
+                }
+            }
+            catch { }
+        }
+    }
+    // 3. Cloud CLIs
+    const cloud = [
+        [['wrangler.toml', 'wrangler.jsonc', 'wrangler.json'], 'npx wrangler deploy', 'Cloudflare Wrangler config'],
+        [['fly.toml'], 'fly deploy', 'Fly.io config (fly.toml)'],
+        [['firebase.json'], 'npx firebase deploy', 'Firebase config (firebase.json)'],
+        [['vercel.json'], 'npx vercel --prod', 'Vercel config (vercel.json)'],
+        [['netlify.toml'], 'npx netlify deploy --prod', 'Netlify config (netlify.toml)'],
+    ];
+    for (const [files, command, label] of cloud) {
+        if (files.some((f) => exists(projectPath, f))) {
+            candidates.push({ method: 'cloud_cli', command, score: 70, evidence: [`${label} found`] });
+            break;
+        }
+    }
+    // 4. Docker Compose: what is actually running beats what merely exists on disk
+    const composeFiles = findComposeFiles(projectPath);
+    const stacks = dockerPs ? parseComposeStacks(dockerPs, projectPath) : [];
+    if (stacks.length > 0) {
+        const stackBuilds = (s) => s.configFiles.some((f) => /^\s+build\s*:/m.test(readText(f)));
+        // The stack that builds the app from this folder matters more than a bigger stack of prebuilt services
+        stacks.sort((a, b) => Number(stackBuilds(b) && b.runningCount > 0) - Number(stackBuilds(a) && a.runningCount > 0) ||
+            Number(stackBuilds(b)) - Number(stackBuilds(a)) ||
+            b.runningCount - a.runningCount);
+        const stack = stacks[0];
+        const files = stack.configFiles.map((f) => (isInside(f, projectPath) ? path.relative(projectPath, f) : f));
+        const builds = stackBuilds(stack);
+        const target = { projectName: stack.projectName, files, running: stack.runningCount > 0 };
+        const isRunning = stack.runningCount > 0;
+        candidates.push({
+            method: 'docker_compose',
+            command: composeCommand(target),
+            // A stack that is up right now is the deployment; a stopped one is only as strong as a file on disk
+            score: builds ? (isRunning ? 75 : 60) : isRunning ? 40 : 25,
+            compose: target,
+            evidence: [
+                `Docker Compose project \`${stack.projectName}\` (${stack.services.length} service${stack.services.length === 1 ? '' : 's'}, ${stack.runningCount} running) was started from ${files.map((f) => `\`${f}\``).join(' + ')}` +
+                    (builds ? '' : ' — it only runs prebuilt images (no `build:`), so it looks like supporting services rather than the app itself'),
+                ...(stacks.length > 1
+                    ? [`${stacks.length - 1} other Compose project(s) also run from this folder: ${stacks.slice(1).map((s) => s.projectName).join(', ')}`]
+                    : []),
+            ],
+        });
+    }
+    else if (composeFiles.length > 0) {
+        const pick = composeFiles.find((f) => f.kind === 'default' && !f.rel.includes('/')) ||
+            composeFiles.find((f) => f.kind === 'default') ||
+            composeFiles.find((f) => f.kind === 'dev' || f.kind === 'other') ||
+            composeFiles[0];
+        const target = { projectName: null, files: pick.rel === 'docker-compose.yml' || pick.rel === 'compose.yaml' || pick.rel === 'compose.yml' || pick.rel === 'docker-compose.yaml' ? [] : [pick.rel], running: false };
+        const score = pick.kind === 'prod' ? 20 : pick.hasBuild ? 60 : 25;
+        candidates.push({
+            method: 'docker_compose',
+            command: composeCommand(target),
+            score,
+            compose: target,
+            evidence: [
+                `Compose file \`${pick.rel}\` exists, but no containers from it are running on this machine` +
+                    (pick.kind === 'prod' ? ' (it looks like a server-side production file)' : '') +
+                    (pick.hasBuild ? '' : ' and it builds nothing from source'),
+            ],
+        });
+    }
+    // 5. Plain git push
+    if (git.isRepo && git.hasRemote) {
+        candidates.push({
+            method: 'git_push',
+            command: null,
+            score: 30,
+            evidence: ['git remote configured; no deploy step found beyond pushing'],
+        });
+    }
+    // Project docs nudge the ranking toward what the humans wrote down
+    const hints = docHints(projectPath);
+    for (const c of candidates) {
+        const n = c.method === 'docker_compose' || c.method === 'github_actions' || c.method === 'deploy_script' ? hints[c.method] : 0;
+        if (n > 0) {
+            c.score = Math.min(95, c.score + Math.min(10, 4 + n * 2));
+            c.evidence.push(`project docs mention this deployment route (${n} reference${n === 1 ? '' : 's'})`);
+        }
+    }
+    return candidates.sort((a, b) => b.score - a.score);
+}
+function confidenceFor(top, second) {
+    if (!top)
+        return 'low';
+    const margin = top.score - (second?.score || 0);
+    if (top.score >= 80 && margin >= 10)
+        return 'high';
+    if (top.score >= 55)
+        return 'medium';
+    return 'low';
+}
+/** Methods that repeatedly failed because they do not apply to this project are pushed down the ranking. */
+function applyMemoryPenalties(candidates, memory) {
+    if (!memory?.failures)
+        return;
+    for (const c of candidates) {
+        const f = memory.failures[c.method];
+        if (f && f.count >= 2 && f.wrong_method) {
+            c.score = Math.max(0, c.score - 45);
+            c.evidence.push(`failed the last ${f.count} attempts on this machine (${f.last_error?.slice(0, 120) || f.last_kind})`);
+        }
+    }
+    candidates.sort((a, b) => b.score - a.score);
+}
+export function resolveDeployProfile(projectPath, options = {}) {
+    const probes = options.probes || {};
+    const git = (probes.git || defaultGitInfo)(projectPath);
+    const workflows = readWorkflows(projectPath);
+    const dockerPs = probes.dockerPs ? probes.dockerPs() : defaultDockerPs();
+    const candidates = gatherCandidates(projectPath, git, workflows, dockerPs);
+    applyMemoryPenalties(candidates, options.memory);
+    const bound = options.bound || null;
+    const memory = options.memory || null;
+    const name = path.basename(projectPath);
+    const explicitFile = readExplicitFile(projectPath);
+    const explicitMemory = memory?.explicit || null;
+    // Live URL: explicit > user-set binding > learned > guess
+    let liveUrl = null;
+    let liveUrlSource = null;
+    const boundSource = (bound?.deploy_source || '').toLowerCase();
+    if (explicitFile?.live_url || explicitMemory?.live_url) {
+        liveUrl = explicitFile?.live_url || explicitMemory?.live_url || null;
+        liveUrlSource = 'explicit';
+    }
+    else if (bound?.live_url && boundSource === 'user') {
+        liveUrl = bound.live_url;
+        liveUrlSource = 'user';
+    }
+    else if (memory?.last_success?.live_url) {
+        liveUrl = memory.last_success.live_url;
+        liveUrlSource = 'learned';
+    }
+    else {
+        liveUrl = inferLiveUrl(projectPath, name, git.remoteUrl);
+        liveUrlSource = liveUrl ? 'guessed' : null;
+    }
+    const base = {
+        liveUrl,
+        liveUrlSource,
+        buildCommand: bound?.build_command || detectBuildCommand(projectPath),
+        workflows,
+        git,
+        deploymentNotes: extractDeploymentNotes(projectPath),
+    };
+    const candidateFor = (method) => candidates.find((c) => c.method === method);
+    const pinned = (method, command, source, why) => {
+        const match = candidateFor(method);
+        const useCommand = isRunnableCommand(command) ? command.trim() : match?.command || null;
+        return {
+            ...base,
+            method,
+            command: useCommand,
+            source,
+            confidence: 'high',
+            evidence: [why, ...(match?.evidence || [])],
+            // A custom compose command is run as given; otherwise reuse the discovered stack (so only the services
+            // affected by a change are rebuilt or restarted, and a changed -p/-f set is picked up).
+            compose: method === 'docker_compose' && (!isRunnableCommand(command) || (command || '').trim() === match?.command)
+                ? match?.compose
+                : undefined,
+            dispatchOnly: Boolean(match?.dispatchOnly),
+            needsConfirmation: false,
+            alternatives: candidates.filter((c) => c.method !== method),
+        };
+    };
+    if (explicitFile) {
+        return pinned(explicitFile.method, explicitFile.command, 'explicit', 'set in `.agilemonster/deploy.json`');
+    }
+    if (explicitMemory) {
+        const method = normalizeMethod(explicitMemory.method);
+        if (method) {
+            return pinned(method, explicitMemory.command || null, 'explicit', `recorded for this project${explicitMemory.set_by ? ` by ${explicitMemory.set_by}` : ''}${explicitMemory.notes ? `: ${explicitMemory.notes.slice(0, 160)}` : ''}`);
+        }
+    }
+    if (bound && boundSource === 'user') {
+        const method = normalizeMethod(bound.deploy_method);
+        if (method)
+            return pinned(method, bound.deploy_command || null, 'user', 'set by a teammate in Agile Monster');
+    }
+    // What worked last time, as long as it has not started failing since
+    const last = memory?.last_success || null;
+    if (last) {
+        const method = normalizeMethod(last.method);
+        const failing = method ? memory?.failures?.[method] : null;
+        const stillPlausible = method && (candidateFor(method) || isRunnableCommand(last.command) || method === 'manual' || method === 'none');
+        if (method && stillPlausible && !(failing && failing.count >= 2)) {
+            return pinned(method, last.command || null, 'learned', `this is how the last successful deployment ran (${last.at.slice(0, 10)}${last.commit ? `, commit ${last.commit}` : ''})`);
+        }
+    }
+    if (bound && boundSource === 'verified') {
+        const method = normalizeMethod(bound.deploy_method);
+        if (method && (candidateFor(method) || isRunnableCommand(bound.deploy_command))) {
+            return pinned(method, bound.deploy_command || null, 'verified', 'verified by an earlier deployment recorded in Agile Monster');
+        }
+    }
+    const top = candidates[0];
+    if (!top) {
+        return {
+            ...base,
+            method: 'none',
+            command: null,
+            source: 'detected',
+            confidence: 'low',
+            evidence: ['no deployment mechanism found in this project (no deploy workflow, script, cloud config, Compose stack, or git remote)'],
+            dispatchOnly: false,
+            needsConfirmation: false,
+            alternatives: [],
+        };
+    }
+    const evidence = [...top.evidence];
+    const boundMethod = normalizeMethod(bound?.deploy_method);
+    if (boundMethod && boundMethod !== top.method) {
+        evidence.push(`an earlier automatic guess stored for this board said \`${boundMethod}\`; the evidence in the project now points to \`${top.method}\``);
+    }
+    const command = top.command || (boundMethod === top.method && isRunnableCommand(bound?.deploy_command) ? bound?.deploy_command : null);
+    return {
+        ...base,
+        method: top.method,
+        command,
+        source: 'detected',
+        confidence: confidenceFor(top, candidates[1]),
+        evidence,
+        compose: top.compose,
+        dispatchOnly: Boolean(top.dispatchOnly),
+        needsConfirmation: requiresConfirmation(top),
+        alternatives: candidates.slice(1),
+    };
+}
+/**
+ * Pushing to the checked-out branch (and whatever pipeline the repo attached to that) and refreshing local
+ * containers are routine. Running a deploy script, a cloud CLI, or manually dispatching a workflow reaches
+ * production in ways the repository did not automate — so an unconfirmed guess must be confirmed once.
+ */
+export function requiresConfirmation(candidate) {
+    return candidate.method === 'deploy_script' || candidate.method === 'cloud_cli' || Boolean(candidate.dispatchOnly);
+}
+const METHOD_LABELS = {
+    github_actions: 'GitHub Actions (push triggers the pipeline)',
+    docker_compose: 'local Docker Compose (rebuild and recreate containers)',
+    deploy_script: 'deploy script',
+    cloud_cli: 'cloud CLI',
+    git_push: 'git push only',
+    manual: 'manual (a human deploys)',
+    none: 'no deployment',
+};
+export function methodLabel(method) {
+    return METHOD_LABELS[method] || method;
+}
+/** Compact, human-readable description used in card comments, the code model's context, and MCP tool output. */
+export function describeProfile(profile) {
+    const lines = [
+        `Deployment method: ${methodLabel(profile.method)}${profile.command ? ` — \`${profile.command}\`` : ''}`,
+        `Confidence: ${profile.confidence} (source: ${profile.source})${profile.needsConfirmation ? ' — not confirmed yet: a background agent will ask before running this the first time' : ''}`,
+        ...profile.evidence.slice(0, 4).map((e) => `- ${e}`),
+    ];
+    if (profile.git.isRepo) {
+        lines.push(`Git: branch \`${profile.git.branch || 'detached'}\`${profile.git.hasRemote ? '' : ', no remote'}`);
+    }
+    if (profile.liveUrl) {
+        lines.push(`Live URL: ${profile.liveUrl}${profile.liveUrlSource === 'guessed' ? ' (guess)' : ''}`);
+    }
+    if (profile.alternatives.length > 0) {
+        lines.push(`Other routes found: ${profile.alternatives
+            .slice(0, 3)
+            .map((a) => `${a.method}${a.command ? ` (\`${a.command}\`)` : ''}`)
+            .join('; ')}`);
+    }
+    return lines.join('\n');
+}